Strings archivos - decodigo.com

¿Qué devuelven las seis expresiones de la imagen? Todo se resume en una idea: == compara si dos referencias apuntan al mismo objeto, y equals compara el contenido. Lo que lía es que, con las cadenas, a veces son el mismo objeto sin que lo parezca.

Las respuestas, ejecutadas

Este programa evalúa las seis expresiones de la imagen y unas cuantas más que ayudan a entenderlas:

import java.util.Objects;

void main() {
    String variable = null;

    IO.println("\"cadena\" == \"cadena\"                    -> " + ("cadena" == "cadena"));
    IO.println("\"cadena\" == \"cad\" + \"ena\"               -> " + ("cadena" == "cad" + "ena"));

    String cad = "cad";
    final String cadFinal = "cad";
    IO.println("\"cadena\" == cad + \"ena\"                 -> " + ("cadena" == cad + "ena"));
    IO.println("\"cadena\" == cadFinal + \"ena\"            -> " + ("cadena" == cadFinal + "ena"));

    IO.println("\"cadena\" == \"-cadena\".substring(1)      -> " + ("cadena" == "-cadena".substring(1)));
    IO.println("new String(\"cadena\") == \"cadena\"        -> " + (new String("cadena") == "cadena"));
    IO.println("new String(\"cadena\").equals(\"cadena\")   -> " + new String("cadena").equals("cadena"));
    IO.println("\"-cadena\".substring(1).intern() == \"cadena\" -> " + ("-cadena".substring(1).intern() == "cadena"));

    IO.println("\"cadena\".equals(variable)               -> " + "cadena".equals(variable));
    IO.println("Objects.equals(variable, \"cadena\")      -> " + Objects.equals(variable, "cadena"));
    IO.println("\"Cadena\".equalsIgnoreCase(\"CADENA\")     -> " + "Cadena".equalsIgnoreCase("CADENA"));
    IO.println("\"abeja\".compareTo(\"abeto\")              -> " + "abeja".compareTo("abeto"));

    try {
        IO.println(variable.equals("cadena"));
    } catch (NullPointerException e) {
        IO.println("variable.equals(\"cadena\") -> " + e);
    }
}

javac -g Cadenas.java
java Cadenas

salida"cadena" == "cadena"                    -> true
"cadena" == "cad" + "ena"               -> true
"cadena" == cad + "ena"                 -> false
"cadena" == cadFinal + "ena"            -> true
"cadena" == "-cadena".substring(1)      -> false
new String("cadena") == "cadena"        -> false
new String("cadena").equals("cadena")   -> true
"-cadena".substring(1).intern() == "cadena" -> true
"cadena".equals(variable)               -> false
Objects.equals(variable, "cadena")      -> false
"Cadena".equalsIgnoreCase("CADENA")     -> true
"abeja".compareTo("abeto")              -> -10
variable.equals("cadena") -> java.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "variable" is null

La opción -g guarda los nombres de las variables locales en el .class, y por eso el último mensaje dice "variable". Si lo ejecutas directamente con java Cadenas.java sale "<local1>" en su lugar: el lanzador compila sin esa información.

Por qué cada una da lo que da

Expresión	Resultado	Por qué
`"cadena" == "cadena"`	true	Los literales iguales se guardan una sola vez, en el pool de cadenas. Los dos son el mismo objeto.
`"cadena" == "cad" + "ena"`	true	Es una expresión constante: el compilador une las dos partes y en el `.class` ya solo está `"cadena"`.
`"cadena" == "-cadena".substring(1)`	false	`substring` crea un objeto nuevo mientras el programa se ejecuta. Mismo texto, otro objeto.
`new String("cadena").equals("cadena")`	true	`equals` compara los caracteres, que son los mismos.
`new String("cadena") == "cadena"`	false	`new` siempre crea un objeto nuevo, distinto del literal.
`new String("cadena") == new String("cadena")`	false	Dos `new`, dos objetos.

Lo interesante está en las dos líneas que añadimos: si una de las partes es una variable normal, la concatenación ocurre al ejecutar y da un objeto nuevo (false). Si la variable es final y se inicializa con un literal, cuenta como constante y el compilador vuelve a unirlas antes de tiempo (true). Es decir, el resultado de == depende de detalles que no se ven al leer el código. Basta un cambio inocente, como quitar un final, para que una comparación que funcionaba deje de hacerlo.

Pasa lo mismo con cualquier texto que llegue de fuera: lo que se lee de un archivo, de la consola o de una petición web son objetos nuevos, aunque contengan exactamente lo mismo que un literal del programa.

La regla: equals, siempre

Para saber si dos cadenas tienen el mismo texto, equals. == solo sirve para preguntar si son el mismo objeto, y eso casi nunca es lo que quieres saber.

intern() devuelve la copia del pool, y por eso "-cadena".substring(1).intern() == "cadena" da true. Es una curiosidad que conviene conocer, pero no una forma de comparar: obliga a acordarse de llamarlo en todas partes.

Cuando la variable puede ser null

Si la variable es null, variable.equals("cadena") lanza un NullPointerException, como se ve en la última línea de la salida. Hay dos formas de evitarlo:

"cadena".equals(variable)

Poner el literal delante: un literal nunca es null, y equals(null) simplemente devuelve false.

Objects.equals(variable, "cadena")

Objects.equals sirve cuando las dos pueden ser null: devuelve true si ambas lo son y nunca lanza la excepción.

Otras comparaciones

Para…	Se usa	Ejemplo
Mismo texto	`a.equals(b)`	`true` / `false`
Mismo texto, con posibles null	`Objects.equals(a, b)`	`true` / `false`
Sin importar mayúsculas	`a.equalsIgnoreCase(b)`	`"Cadena"` y `"CADENA"` → `true`
Ordenar	`a.compareTo(b)`	negativo, cero o positivo: `"abeja"` va antes que `"abeto"` → `-10`

El -10 de compareTo no es una distancia con significado: es la diferencia entre la primera pareja de caracteres que no coinciden (j y t). Lo único que importa es el signo.

Entrada publicada en 2013 y revisada en octubre de 2026. Todo el código se compiló y se ejecutó con Java 25 LTS en un contenedor limpio; las salidas están copiadas de esa ejecución.