String Java é igual()

Comparar objetos quanto à equivalência é uma das operações de programação mais importantes. No entanto, apesar de toda a sua obviedade no mundo numérico, nem sempre é claro como comparar outros tipos de dados. A classe Java Object , básica, define os métodos equals() e compareTo() para comparação. A classe String substitui seu método equals() . O método Java String equals() compara duas strings de acordo com seu conteúdo. A assinatura do método String equals() se parece com isto:

public boolean equals(Object anotherObject)

O método String equals() compara a string com o objeto especificado. Se as strings forem iguais, retorna verdadeiro, caso contrário, é falso. Você deve estar se perguntando por que não comparar strings usando o operador de comparação == ? Na verdade, isso também é possível, mas o resultado será um pouco diferente. O fato é que o operador == compara endereços na memória. Portanto, se s1 == s2 retornar true , essas duas strings terão o mesmo endereço na memória. Ao mesmo tempo, equals verifica a igualdade do conteúdo das strings. Vejamos um exemplo de comparação de duas strings.

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

   }
}

A saída deste programa é: Vamos dar uma olhada mais de perto no que está acontecendo aqui. Quando criamos uma string, ela é colocada no pool de strings, uma área especial da memória. As strings ocupam uma grande parte de todos os objetos em qualquer programa grande. Então para economizar memória foi criado o String Pool, onde é colocada uma string com o texto que você precisa. Links recém-criados posteriormente referem-se à mesma área de memória, não há necessidade de alocar memória adicional a cada vez. Se você criar uma string sem operador new, ou seja, quando você escrever

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

ou algo parecido, o programa verifica se existe uma String com esse texto no pool de String. Se for, nenhuma nova String será criada. E o novo link apontará para o mesmo endereço no String Pool onde essa String já está armazenada. Então, quando escrevemos no programa

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

a referência myString1 aponta exatamente para o mesmo local na memória que myString2 . O primeiro comando criou uma nova string no String Pool com o texto que precisávamos e, quando chegou ao segundo, simplesmente se referiu à mesma área de memória que myString1 . Mas a string myString4 foi criada como um objeto usando o operador new . Este operador aloca uma nova área na memória para um objeto quando ele é criado. Uma string criada com new

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

não cai no String Pool, mas se torna um objeto separado, mesmo que seu texto corresponda completamente à mesma string do String Pool. Além disso, se compararmos strings usando o método String equals() , ele verificará não o endereço, mas o conteúdo da string, a sequência de caracteres nas strings. E se o texto nas strings for o mesmo, não importa como elas foram criadas e onde estão armazenadas, no String Pool ou em uma área de memória separada. É por isso que myString1 , myString2 e myString4 foram iguais nesta comparação. A propósito, você notou que o método String equals() permite comparar strings corretamente diferenciando maiúsculas de minúsculas? Ou seja, se compararmos a string “minha string” com as strings “Minha string” e “MINHA STRING” obtemos 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

   }
}

A saída está aqui: Para comparar strings sem diferenciar maiúsculas de minúsculas, Java possui um método muito semelhante a equals :

boolean equalsIgnoreCase​(String anotherString)

Vamos usá-lo em nosso exemplo.

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));

   }
}

Agora a saída é: