1. Comparación de cadenas

Todo esto está muy bien. Pero puede ver que las cadenas s1y s2son en realidad las mismas, lo que significa que contienen el mismo texto. Al comparar cadenas, ¿cómo le dice al programa que no mire las direcciones de Stringlos objetos, sino su contenido?

Para ayudarnos con esto, Stringla clase de Java tiene el equalsmétodo. Llamarlo se ve así:

string1.equals(string2)
Comparando dos cadenas

Este método devuelve truesi las cadenas son iguales y falsesi no lo son.

Ejemplo:

Código Nota
String s1 = "Hello";
String s2 = "HELLO";
String s3 = s1.toUpperCase();

System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println(s2.equals(s3));
// Hello
// HELLO
// HELLO

false // They are different
false // They are different
true // They are the same, even though the addresses are different

Más ejemplos:

Código Explicación
"Hello".equals("HELLO")
false
String s = "Hello";
"Hello".equals(s);
true
String s = "Hel";
"Hello".equals(s + "lo");
true
String s = "H";
(s + "ello").equals(s + "ello");
true


2. Comparación de cadenas que no distingue entre mayúsculas y minúsculas

En el último ejemplo, viste que la comparación da como resultado . De hecho, las cuerdas no son iguales. Pero..."Hello".equals("HELLO")false

Claramente, las cuerdas no son iguales. Dicho esto, su contenido tiene las mismas letras y solo se diferencia por el caso de las letras. ¿Hay alguna forma de compararlos y prescindir del caso de las letras? Es decir, por lo que los rendimientos ?"Hello".equals("HELLO")true

Y la respuesta a esta pregunta es sí. En Java, el Stringtipo tiene otro método especial: equalsIgnoreCase. Llamarlo se ve así:

string1.equalsIgnoreCase(string2)

El nombre del método se traduce aproximadamente como comparar pero ignorar caso . Las letras en el nombre del método incluyen dos líneas verticales: la primera es minúscula Ly la segunda es mayúscula i. No dejes que eso te confunda.

Ejemplo:

Código Nota
String s1 = "Hello";
String s2 = "HELLO";
String s3 = s1.toUpperCase();

System.out.println(s1.equalsIgnoreCase(s2));
System.out.println(s1.equalsIgnoreCase(s3));
System.out.println(s2.equalsIgnoreCase(s3));
// Hello
// HELLO
// HELLO

true
true
true


3. Ejemplo de comparación de cadenas

Demos solo un ejemplo simple: supongamos que necesita ingresar dos líneas desde el teclado y determinar si son iguales. Así es como se verá el código:

Scanner console = new Scanner(System.in);
String a = console.nextLine();
String b = console.nextLine();
String result = a.equals(b) ? "Same" : "Different";
System.out.println(result);

4. Un interesante matiz de comparación de cadenas

Hay un matiz importante que debes tener en cuenta.

Si el compilador de Java encuentra varias cadenas idénticas en su código (específicamente en su código), creará un solo objeto para ellas para ahorrar memoria.

String text = "This is a very important message";
String message = "This is a very important message";

Y esto es lo que contendrá la memoria como resultado:

comparación de cadenas

Y si comparas text == messageaquí, entonces obtienes true. Así que no te sorprendas por eso.

Si por alguna razón realmente necesita que las referencias sean diferentes, puede escribir esto:

String text = "This is a very important message";
String message = new String ("This is a very important message");

O esto:

String text = "This is a very important message";
String message = new String (text);

En ambos casos, las variables texty messageapuntan a diferentes objetos que contienen el mismo texto.