Introducción

Comparar strings o cadenas en Java es algo simple de hacer, pero que podemos hacer mal si no sabemos cuál es la forma correcta. Recordemos que Java trata a las cadenas como objetos, no como tipos primitivos.

Debido a eso, comparar cadenas en Java requiere algo más que usar el operador de igualdad ==.

Veamos hoy cómo podemos comparar cadenas, ya sea para saber si son equivalentes o para saber si una es menor o mayor que otra según el alfabeto.

Sobre las strings o cadenas en Java

Como lo dije al inicio, un String en Java es un objeto. No es un tipo primitivo como un booleano o un entero. Si testeamos la igualdad de una cadena usando == eso comparará la igualdad de objetos, es decir, comprobará si las dos cadenas son los mismos objetos; no el contenido de las mismas.

Esto puede traer graves complicaciones, pues si, por ejemplo 2 cadenas tienen el mismo contenido pero son instancias diferentes, el operador de igualdad regresará false.

Veamos este simple ejemplo:

/*
  Probar igualdad de cadenas usando Java
  parzibyte.me/blog
*/class Main {
  public static void main(String[] args) {
 
    // Dos cadenas que tienen el mismo contenido.
    // Deberían ser iguales, ¿verdad?
    String unaCadena = new String("Hola");
    String otraCadena = new String("Hola");
 
    // Vamos a comprobarlo:
    if(unaCadena == otraCadena){
      System.out.println("Las cadenas son iguales :-)");
    }else{
      System.out.println("Las cadenas no son iguales :(");
    }
  }
}

La salida del programa es que las cadenas no son iguales. Esto es porque son diferentes instancias, no apuntan a la misma dirección de memoria o referencia, si lo queremos ver de ese modo.

Y bueno, tú dirás: pero yo nunca declaro cadenas usando el operador new, siempre pongo String cadena = "Contenido".

Lo sé, pero en la práctica nunca sabrás de dónde viene la cadena, qué tal si la obtienes de un textbox de Swing, o de una clase distinta que siempre regrese una nueva instancia.

Es decir, no siempre declararás las cadenas tú mismo.
Veamos ahora sí el modo correcto.

Comparar cadenas para ver si el contenido es igual

Pues bien, los objetos tienen un método llamado equals, que en español vendría siendo un equivale o es igual a. Lo que hace es que te dice si lógicamente la cadena equivale a otra, ahora sí comparando su contenido (al menos en el caso de los tipos String)

Para usarlo, usamos cadena.equals(otraCadena) o cadena.equals("Hola"), es decir, probamos dos cadenas, ya sea poniendo las variables o la cadena en sí.

Veamos el ejemplo de arriba pero ahora sí comparando bien. Comparar cadenas en Java de la forma correcta se hace así:

/*
  Probar igualdad de cadenas usando Java (forma correcta)
  parzibyte.me/blog
*/class Main {
  public static void main(String[] args) {
 
    // Dos cadenas que tienen el mismo contenido.
    // Deberían ser iguales, ¿verdad?
    String unaCadena = new String("Hola");
    String otraCadena = new String("Hola");
 
    // Vamos a comprobarlo:
    if(unaCadena.equals(otraCadena)){
      System.out.println("Las cadenas son iguales :-)");
    }else{
      System.out.println("Las cadenas no son iguales :(");
    }
  }
}

Lo mismo de arriba, pero usando equals en lugar del operador de igualdad. La salida es que sí, ahora sí son iguales las cadenas.

Entonces, ¿cuál usar, equals o ==?

Si no estás trabajando con referencias a objetos y esas cosas, y simplemente quieres saber si las dos cadenas tienen el mismo contenido usa equals. La mayoría de veces harás eso.

En cambio, si quieres ver la igualdad de objetos y cosas de esas (más avanzadas) usa el operador ==, tú sabes lo que haces.

Otras formas de comparar cadenas

De hecho este post viene porque estaba investigando cómo comparar cadenas en Java pero de forma que sean comparadas según el alfabeto.

Llegué a la página de Oracle. Según eso, la API especifica un método llamado compareTo, que funciona casi como equals a diferencia de que éste devuelve un entero, no un booleano.

Devuelve un entero porque nos dice si la cadena es menor, mayor o igual a otra; haciendo comparaciones lexicográficamente.

Usando compareTo en Java

Citando las palabras de Oracle, y pasándolas directamente al traductor de Google para más tarde corregir sus errores según yo, damos con esto:

Compara dos cadenas lexicográficamente. La comparación se basa en el valor Unicode de cada carácter en las cadenas. La secuencia de caracteres representada por la cadena a la que apunta this se compara lexicográficamente con la secuencia de caracteres representada por el argumento string. El resultado es un entero negativo si la cadena a la que apunta a this precede de forma lexicográfica a la cadena del argumento. El resultado es un entero positivo si la cadena a la que apunta this está después o es mayor que la cadena del argumento. El resultado es cero si las cadenas son iguales; compareTo devuelve 0 exactamente cuando el método equals devolvería verdadero.

Ejemplo de uso de compareTo

Pero basta de texto, veamos un ejemplo de código. Avión es menor que Barco, porque en el alfabeto la A está antes de la B.

Entonces si comparamos estas cadenas, el resultado debería ser un entero negativo:

class Main {
  public static void main(String[] args) {
    String cadena = "Avión",
    otraCadena = "Barco";
    int resultado = cadena.compareTo(otraCadena);
    System.out.println("Al comparar " + cadena + " con " + otraCadena + " el resultado es " + resultado);
  }
}

El resultado es, como lo dije, negativo. Pues la A va antes de la B.

Entonces, si la primera cadena es menor que la segunda, devolverá un entero negativo. Si es igual, devuelve 0. Y si es mayor, devuelve un entero positivo. Casi como cuando comparamos cadenas en PHP.

Un ejercicio más con compareTo

Hagamos este ejercicio para entenderlo mejor. Ingresas dos cadenas y te dice si es mayor, menor o igual.

/*
  Programa que compara 2 cadenas y te dice si una es menor, mayor o igual que la segunda
  parzibyte.me/blog
*/ 
import java.util.Scanner;
class Main {
  public static void main(String[] args) {
    System.out.println("****\n\tPrograma que te dice si una cadena es menor que otra\n\tparzibyte.me/blog\n****");
    Scanner sc = new Scanner(System.in);
    System.out.println("Ingresa una cadena:");
    String primerCadena = sc.nextLine();
    System.out.println("Ingresa otra cadena: ");
    String segundaCadena = sc.nextLine();
    int resultado = primerCadena.compareTo(segundaCadena);
    if(resultado == 0){
     System.out.println("La primer cadena es igual que la segunda"); 
    }else if(resultado > 0){
      System.out.println("La primer cadena es mayor que la segunda");
    }else{
      // Si resultado < 0
      System.out.println("La primer cadena es menor que la segunda");
    }
  }
}

Simplemente lee las dos cadenas con Scanner, luego compara con compareTo y hace unos if’s con el resultado. A partir de ello imprime si una cadena es menor, mayor o igual que otra.

Al ejecutarlo con los 3 posibles escenarios obtengo esto:

Conclusión

Así es como comparamos cadenas con Java. En resumen, para una comparación de igualdad usa el método equals. Si estás ordenando cadenas o comparándolas lexicográficamente usa compareTo.

Cabe mencionar que también existe compareToIgnoreCase, que compara ignorando si son mayúsculas o minúsculas; por ejemplo, ese método diría que “hOlA” y “hola” son iguales.