1. Comparación de referencias y de contenido
En Java, las cadenas son objetos, no tipos primitivos. Cuando declaras variables a y b, pueden apuntar a la misma cadena en el pool de cadenas. En cambio, c, creada mediante el constructor, ya es otro objeto. El operador == compara referencias, no el texto.
String a = "hello";
String b = "hello";
String c = new String("hello");
System.out.println(a == b); // true (probablemente, cadena internada)
System.out.println(a == c); // false (objetos distintos)
Demostración del error
String s1 = "Java";
String s2 = new String("Java");
System.out.println(s1 == s2); // false
Aunque las cadenas parecen iguales, son objetos distintos en memoria.
2. equals(): comparación del contenido de las cadenas
Para comparar el contenido, usa el método equals() — compara las cadenas carácter por carácter (distingue mayúsculas y minúsculas).
String s1 = "Java";
String s2 = new String("Java");
System.out.println(s1.equals(s2)); // true
Ejemplo: comparación de contraseñas
String inputPassword = "Secret123";
String realPassword = "Secret123";
if (inputPassword.equals(realPassword))
{
System.out.println("¡Acceso permitido!");
}
else
{
System.out.println("Contraseña incorrecta.");
}
Importante
Si al menos uno de los objetos es null, llamar a equals() provocará un NullPointerException. Patrón seguro:
if ("algo".equals(someString)) { ... }
3. equalsIgnoreCase(): comparación sin tener en cuenta mayúsculas/minúsculas
Cuando es importante ignorar el caso (por ejemplo, la entrada del usuario), usa equalsIgnoreCase().
String name1 = "Ivan";
String name2 = "ivan";
System.out.println(name1.equalsIgnoreCase(name2)); // true
Ejemplo: comparación de direcciones de correo electrónico
String email1 = "User@Example.com";
String email2 = "user@example.com";
if (email1.equalsIgnoreCase(email2))
{
System.out.println("¡Los correos coinciden!");
}
En breve: equals vs equalsIgnoreCase
| Método | ¿Tiene en cuenta mayúsculas/minúsculas? | Ejemplo «Java» vs «java» |
|---|---|---|
|
Sí | |
|
No | |
4. compareTo(): comparación lexicográfica de cadenas
El método compareTo() realiza una comparación lexicográfica (de diccionario). Devuelve un número negativo si la primera cadena es «menor», 0 — si son iguales, y un número positivo — si es «mayor».
System.out.println("apple".compareTo("banana")); // < 0
System.out.println("apple".compareTo("apple")); // 0
System.out.println("banana".compareTo("apple")); // > 0
a.compareTo(b) →
< 0 — si a va antes que b
0 — si son iguales
> 0 — si a va después de bcompareTo()
¿Cómo funciona?
- La comparación va de izquierda a derecha según los códigos Unicode de los caracteres.
- En la primera diferencia se devuelve la diferencia de los códigos de los caracteres.
- Si una cadena es prefijo de la otra, la más corta es «menor».
System.out.println("cat".compareTo("catalog")); // < 0 ("cat" es más corta)
System.out.println("catalog".compareTo("cat")); // > 0
Ejemplo: ordenar un array de cadenas
String[] fruits = {"banana", "apple", "pear"};
Arrays.sort(fruits); // internamente se usa compareTo()
System.out.println(Arrays.toString(fruits)); // [apple, banana, pear]
compareToIgnoreCase()
System.out.println("Java".compareToIgnoreCase("java")); // 0
Métodos startsWith() y endsWith()
Los métodos startsWith() y endsWith() comprueban el inicio y el final de una cadena, devolviendo true/false.
String fileName = "document.pdf";
String url = "https://www.google.com";
System.out.println(fileName.startsWith("doc")); // true
System.out.println(fileName.endsWith(".txt")); // false
System.out.println(url.startsWith("https://")); // true
¿Para qué sirve? Validación de formatos (nombres de archivos, URL) y filtrado por prefijos/sufijos (por ejemplo, todos los ".jpg").
Método contains(): buscar una subcadena
contains(CharSequence s) es una forma sencilla de comprobar si existe una subcadena. Es sensible al caso.
String text = "¡Bienvenido al mundo de Java!";
System.out.println(text.contains("mundo")); // true
System.out.println(text.contains("C++")); // false
Para ignorar mayúsculas/minúsculas, convierte ambas cadenas al mismo caso: toLowerCase()/toUpperCase().
Métodos toLowerCase() y toUpperCase()
Devuelven una cadena nueva convertida a minúsculas o mayúsculas. Útil para comparaciones insensibles al caso y para formato.
String title = "Java Programming";
String lower = title.toLowerCase();
String upper = title.toUpperCase();
System.out.println(lower); // java programming
System.out.println(upper); // JAVA PROGRAMMING
Método split(): dividir una cadena en partes
split(String regex) divide la cadena por un separador (expresión regular) y devuelve un array String[].
Ejemplo 1: por comas
String names = "Alex,Maria,Ivan,Elena";
String[] nameArray = names.split(",");
for (String name : nameArray)
{
System.out.println(name.trim()); // trim() elimina posibles espacios
}
// Salida:
// Alex
// Maria
// Ivan
// Elena
Ejemplo 2: por espacios
String sentence = "Estoy estudiando Java";
String[] words = sentence.split(" ");
for (String word : words)
{
System.out.println(word);
}
// Salida:
// Estoy
// estudiando
// Java
Particularidades:
- El separador es una expresión regular. Los caracteres especiales deben escaparse (por ejemplo, el punto: "\\.").
- El método siempre devuelve un array, incluso si hay un solo elemento.
Práctica: comparamos cadenas en una aplicación real
String registeredEmail = "user@example.com";
String registeredPassword = "Secret123";
Scanner console = new Scanner(System.in);
System.out.print("Introduzca el email: ");
String email = console.nextLine();
System.out.print("Introduzca la contraseña: ");
String password = console.nextLine();
// Comparamos el email sin tener en cuenta el caso y la contraseña respetando el caso
if (email.equalsIgnoreCase(registeredEmail) && password.equals(registeredPassword))
{
System.out.println("¡Bienvenido!");
}
else
{
System.out.println("Email o contraseña incorrectos.");
}
Comentarios: para el correo usamos equalsIgnoreCase(), y para la contraseña — estrictamente equals(). El operador == no debe usarse con cadenas: compara referencias.
10. Errores típicos al comparar cadenas
Error n.º 1: comparar cadenas con == en lugar de equals()
El operador == compara referencias, no el contenido, por lo que el resultado puede ser inesperado.
Error n.º 2: invocar equals() sobre un objeto que puede ser null
Llama al método sobre un objeto que sepas que no es null o usa Objects.equals(a, b).
Error n.º 3: ignorar mayúsculas/minúsculas cuando importa
Por ejemplo, las contraseñas deben compararse respetando el caso. Aclara los requisitos.
Error n.º 4: comparar cadenas con objetos de otros tipos
"123" y 123 no son lo mismo. equals() no convierte tipos automáticamente.
Error n.º 5: ordenar cadenas con mayúsculas y minúsculas mezcladas
Las mayúsculas van antes que las minúsculas. Para ordenar sin tener en cuenta el caso, usa Arrays.sort(array, String.CASE_INSENSITIVE_ORDER).
GO TO FULL VERSION