En el desarrollo con Java, es frecuente encontrar código que a simple vista parece correcto y completo, pero que en realidad esconde trampas lógicas que pueden llevar a comportamientos inesperados o fallos graves en ciertas condiciones. A continuaicón, se exploran varios ejemplos comunes de estas trampas, con fragmentos de código modificados para ilustrar los problemas sin alterar su esencia.

1. Trampa en bucles al modificar colecciones durante la iteración

List<Integer> dataList = new ArrayList<>(Arrays.asList(10, 20, 30, 40, 50));
int targetValue = 30;
for (int pos = 0; pos < dataList.size(); pos++) {
    if (dataList.get(pos).equals(targetValue)) {
        dataList.remove(pos);
    }
}

Este código intenta eliminar un elemento específico de una lista, pero al remover el elemento, el tamaño de la lista disminuye y el índice pos continúa incrementándose, lo que omite elementos posteriores. Una solución correcta sería usar un iterador o recorrer la lista en orden inverso.

2. Trampa de precisión en comparaciones con números de punto flotante

double val1 = 0.1 + 0.2;
double val2 = 0.3;
if (val1 == val2) {
    System.out.println("Son iguales");
}

Debido a las imprecisiones inherentes en la representación de números de punto flotante, esta condición generalmente no se cumple como se espera. En Java, es recomendable utilizar un rango de tolerancia o la clase BigDecimal para comparaciones exactas.

3. Trampa en la comparación de cadenas por referencia

String firstStr = new String("ejemplo");
String secondStr = "ejemplo";
if (firstStr == secondStr) {
    System.out.println("Cadenas iguales");
}

Este código compara referencias de objetos en lugar de valores, por lo que incluso con contenido idéntico, la condición será falsa. Se debe usar el método equals() para comparar el contenido de las cadenas.

4. Trampa por omisión de verificación de valores nulos

public void analyzeInput(String inputText) {
    if (inputText.length() > 0) {
        // Lógica de procesamiento
    }
}

Si se pasa un valor nulo como arugmento, este código lanzará una NullPointerException. Es crucial verificar si el valor es nulo antes de operar sobre él.

5. Trampa por no liberar recursos adecuadamente

try {
    BufferedReader bufferedReader = new BufferedReader(new FileReader("archivo.txt"));
    // Operaciones de lectura
} catch (IOException exception) {
    exception.printStackTrace();
}

Este fragmento no cierra el recurso en un bloque finally, lo que puede causar fugas de recursos. Se recomienda utilizar la estructura try-with-resources para garantizar la liberación automática.

6. Trampa en entornos concurrentes por falta de sincronización

public class BalanceAccount {
    private double currentBalance = 0.0;
    public void addFunds(double amount) {
        currentBalance += amount;
    }
}

En un contexto multihilo, la operación de incremento no es atómica, lo que puede resultar en condiciones de carrera. Para evitralo, se deben usar mecanismos como AtomicDouble o bloques sincronizados.

7. Trampa al silenciar excepciones en el manejo de errores

try {
    // Código que podría fallar
} catch (Exception error) {
    // Bloque vacío o sin acción
}

Este enfoque oculta problemas, dificultando la depuración. Al menos, se debe registrar la excepción o implementar una lógica de recuperación apropiada.

Estas trampas comparten una característica: el código es sintácticamente válido, compila sin errores y puede funcionar en pruebas básicas. Sin embargo, bajo condiciones específicas, revelan fallos que a menudo son difíciles de diagnosticar en producción. Para prevenirlas, es esencial entender a fondo los mecanismos de Java, escribir pruebas unitarias exhaustivas, utilizar herramientas de análisis estático y adoptar prácticas de programación defensiva.