Cadena Java es igual()

Comparar objetos para determinar su equivalencia es una de las operaciones de programación más importantes. Sin embargo, a pesar de su obviedad en el mundo numérico, no siempre está claro cómo comparar otros tipos de datos. La clase Java Object , una básica, define los métodos equals() y compareTo() para comparar. La clase String anula su método equals() . El método Java String equals() compara dos cadenas según su contenido. La firma del método String equals() se ve así:

public boolean equals(Object anotherObject) 

El método String equals() compara la cadena con el objeto especificado. Si las cadenas son iguales, devuelve verdadero; de lo contrario, es falso. Quizás se pregunte por qué no comparar cadenas utilizando el operador de comparación == . De hecho, esto también es posible, pero el resultado será algo diferente. El hecho es que el operador == compara direcciones en la memoria. Entonces, si s1 == s2 devuelve verdadero , estas dos cadenas tienen la misma dirección en la memoria. Al mismo tiempo, igual comprueba la igualdad del contenido de las cadenas. Tomemos un ejemplo de comparación de dos cadenas.

public class StringEqualsTest {
   //program to test Java equals() method
   public static void main(String[] args) {
       String myString1 = "here is my favorite string";
       String myString2 = "here is my favorite string"; //this string is the same as the previous one, at least we think so 
       String myString3 = "here is My favorite string"; //this string looks a little bit like previous two, but the first letter is big M instead of small m       
       String myString4 = new String("here is my favorite string");
//here we create a String in an object manner… Why? Find out soon  
       String myString5 = "equals to myString1? No, not at all..."; //here we have absolutely different string. Just for fun 
    //let’s compare myString1 with myString2 using “==” operator  
       System.out.println(myString1 == myString2); //true
    //let’s compare myString1 with myString4 using “==” operator  
       System.out.println(myString1 == myString4); //false    
//and now we are going to use equals() method to compare myString1 with myString4, myString2 and myString5  
     System.out.println(myString1.equals(myString4));//true
       System.out.println(myString1.equals(myString2));//true
       System.out.println(myString1.equals(myString5)); //false

   }
}

El resultado de este programa es: Echemos un vistazo más de cerca a lo que está pasando aquí. Cuando creamos una cadena, se coloca en el grupo de cadenas, un área especial de la memoria. Las cadenas ocupan una gran parte de todos los objetos en cualquier programa grande. Entonces para ahorrar memoria se creó String Pool, donde se coloca una cadena con el texto que necesitas. Los enlaces recién creados posteriormente se refieren a la misma área de memoria, no es necesario asignar memoria adicional cada vez. Si crea una cadena sin operador nuevo, es decir, cuando escribe

String  myStringName = "...........................................", 

o algo así, el programa comprueba si hay una cadena con dicho texto en el grupo de cadenas. Si es así, no se creará ninguna cadena nueva. Y el nuevo enlace apuntará a la misma dirección en el grupo de cadenas donde esa cadena ya está almacenada. Entonces cuando escribimos en el programa

 String myString1 = "here is my favorite string";
 String myString2 = "here is my favorite string";

la referencia myString1 apunta exactamente al mismo lugar en la memoria que myString2 . El primer comando creó una nueva cadena en el grupo de cadenas con el texto que necesitábamos, y cuando llegó el segundo, simplemente se refería a la misma área de memoria que myString1 . Pero la cadena myString4 se creó como un objeto usando el nuevo operador. Este operador asigna una nueva área en la memoria para un objeto cuando se crea. Una cadena creada con new

 String myString1 = new String ("here is my favorite string");
 String myString2 = new String ("here is my favorite string");

no cae en el String Pool, sino que se convierte en un objeto separado, incluso si su texto coincide completamente con la misma cadena del String Pool. Además, si comparamos cadenas usando el método String equals() , comprobará no la dirección, sino el contenido de la cadena, la secuencia de caracteres en las cadenas. Y si el texto en las cadenas es el mismo, no importa cómo se crearon y dónde se almacenan, en el String Pool o en un área de memoria separada. Es por eso que myString1 , myString2 y myString4 fueron iguales en esta comparación. Por cierto, ¿has notado que el método String equals() te permite comparar cadenas correctamente distinguiendo entre mayúsculas y minúsculas? Es decir, si comparamos la cadena "mi cadena" con las cadenas "Mi cadena" y "MI CUERDA" obtenemos falso.

public class StringEqualsTest {

   public static void main(String[] args) {

       String myString1 = new String ("here is my favorite string");
       String myString2 = new String ("here is My favorite string");
       String myString3 = new String("HERE IS MY FAVORITE STRING");
      
       System.out.println(myString1.equals(myString2)); //false because first string myString1 has small m and myString2 has big M instead 
       System.out.println(myString1.equals(myString3));//false because myString1 is in lowercase while myString3 is in uppercase

   }
}

El resultado está aquí: Para comparar cadenas sin distinguir entre mayúsculas y minúsculas, Java tiene un método que es muy similar a igual :

boolean equalsIgnoreCase​(String anotherString)

Usémoslo en nuestro ejemplo.

public class StringEqualsTest {

   public static void main(String[] args) {

       String myString1 = new String ("here is my favorite string");
       String myString2 = new String ("here is My favorite string");
       String myString3 = new String("HERE IS MY FAVORITE STRING");
     /* here we are going to use the brother of equals() method, equalsIgnoreCase(). It can help to check user input when case isn’t 
important */ 
       System.out.println(myString1.equalsIgnoreCase(myString2));

       System.out.println(myString1.equalsIgnoreCase(myString3));

   }
}

Ahora la salida es: