Principales errores de desarrolladores Java principiantes: nivel avanzado

Principales errores de desarrolladores Java principiantes: nivel avanzado

Muchos desarrolladores, después de dominar los fundamentos de Java, pasan a escribir código más complejo, pero siguen cometiendo errores típicos que reducen el rendimiento y la confiabilidad de las aplicaciones. En este artículo analizaremos los principales errores a nivel avanzado que cometen los desarrolladores Java y mostraremos cómo evitarlos. El artículo será útil para quienes ya conocen la sintaxis del lenguaje pero desean profundizar sus conocimientos.

1. Uso incorrecto de Optional

La clase Optional se introdujo en Java 8 para combatir NullPointerException. Sin embargo, muchos desarrolladores la usan incorrectamente, convirtiendo una solución elegante en una fuente de nuevos problemas.

Error: Usar Optional.get() sin verificación

Uno de los errores más comunes es llamar al método get() sin antes verificar isPresent(). Esto provoca la excepción NoSuchElementException.

// IncorrectoOptional<String> name = Optional.ofNullable(getName());String result = name.get(); // Excepción si name == null

// CorrectoString result = name.orElse("Default");// O con manejoname.ifPresent(System.out::println);

Error: Usar Optional en campos de clase

Optional no está diseñado para usarse como campo de clase o parámetro de método. Esto rompe la serialización y añade complejidad innecesaria.

// Incorrectopublic class User {    private Optional<String> email; // No se serializa}

// Correctopublic class User {    private String email; // null significa ausencia}

Error: Cadenas de Optional.orElse() con cálculos costosos

El método orElse() evalúa el argumento siempre, incluso si el valor está presente. Use orElseGet() para cálculos perezosos.

// Incorrecto — expensiveCall() se ejecuta siempreString result = optional.orElse(expensiveCall());

// Correcto — expensiveCall() se ejecuta solo si el valor está ausenteString result = optional.orElseGet(() -> expensiveCall());

2. Fugas de memoria y mal manejo de colecciones

Los desarrolladores avanzados a menudo se enfrentan a fugas de memoria difíciles de detectar. Veamos las causas principales.

Error: Olvidar sobrescribir equals() y hashCode()

Al usar objetos en HashMap o HashSet sin equals() y hashCode() correctos, los objetos no se eliminan de la colección, lo que provoca fugas.

public class Key {    private int id;        // Olvidamos sobrescribir equals() y hashCode()    // Ahora las claves se consideran diferentes, incluso si id coincide}

Map<Key, String> map = new HashMap<>();map.put(new Key(1), "value");map.get(new Key(1)); // null — fuga de memoria

Error: Almacenar objetos grandes en colecciones static

Las colecciones estáticas viven hasta que la aplicación termina. Si se agregan datos sin control, esto lleva a OutOfMemoryError.

// Mala prácticapublic class CacheManager {    private static List<byte[]> cache = new ArrayList<>();        public static void addData(byte[] data) {        cache.add(data); // Crece indefinidamente    }}

// Solución: use WeakHashMap o limite el tamañoprivate static Map<String, byte[]> cache = new WeakHashMap<>();

Error: Cerrar recursos mediante finalize()

El método finalize() está obsoleto y no es confiable. Use try-with-resources para el cierre automático.

// Incorrectopublic class Resource {    @Override    protected void finalize() throws Throwable {        // Cierre del recurso — puede no ejecutarse