Chaîne Java égale()

La comparaison d'objets pour l'équivalence est l'une des opérations de programmation les plus importantes. Cependant, malgré toute son évidence dans le monde numérique, il n’est pas toujours clair comment comparer d’autres types de données. La classe Java Object , de base, définit les méthodes equals() et compareTo() à des fins de comparaison. La classe String remplace sa méthode equals() . La méthode Java String equals() compare deux chaînes en fonction de leur contenu. La signature de la méthode String equals() ressemble à ceci :

public boolean equals(Object anotherObject)

La méthode String equals() compare la chaîne à l’objet spécifié. Si les chaînes sont égales, cela renvoie vrai, sinon c'est faux. Vous vous demandez peut-être pourquoi ne pas comparer les chaînes à l’aide de l’ opérateur de comparaison == ? En fait, c'est également possible, mais le résultat sera quelque peu différent. Le fait est que l' opérateur == compare les adresses en mémoire. Donc si s1 == s2 renvoie true , ces deux chaînes ont la même adresse en mémoire. En même temps, equals vérifie l’égalité du contenu des chaînes. Prenons un exemple de comparaison de deux chaînes.

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

   }
}

Le résultat de ce programme est : Regardons de plus près ce qui se passe ici. Lorsque nous créons une chaîne, elle est placée dans le pool de chaînes, une zone spéciale de mémoire. Les chaînes occupent une grande partie de tous les objets de tout grand programme. Ainsi, pour économiser de la mémoire, String Pool a été créé, où est placée une chaîne avec le texte dont vous avez besoin. Les liens nouvellement créés ultérieurement font référence à la même zone mémoire, il n'est pas nécessaire d'allouer de la mémoire supplémentaire à chaque fois. Si vous créez une chaîne sans nouvel opérateur, c'est-à-dire lorsque vous écrivez

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

ou quelque chose comme ça, le programme vérifie s'il existe une chaîne avec un tel texte dans le pool de chaînes. Si tel est le cas, aucune nouvelle chaîne ne sera créée. Et le nouveau lien pointera vers la même adresse dans le pool de chaînes où cette chaîne est déjà stockée. Alors quand nous avons écrit dans le programme

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

la référence myString1 pointe exactement au même endroit en mémoire que myString2 . La première commande a créé une nouvelle chaîne dans le String Pool avec le texte dont nous avions besoin, et quand il s'agissait de la seconde, elle faisait simplement référence à la même zone mémoire que myString1 . Mais la chaîne myString4 a été créée en tant qu'objet à l'aide de l'opérateur new . Cet opérateur alloue une nouvelle zone en mémoire à un objet lors de sa création. Une chaîne créée avec new

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

ne tombe pas dans le pool de chaînes, mais devient un objet distinct, même si son texte correspond complètement à la même chaîne du pool de chaînes. De plus, si nous comparons des chaînes à l’aide de la méthode String equals() , elle ne vérifiera pas l’adresse, mais le contenu de la chaîne, la séquence de caractères dans les chaînes. Et si le texte des chaînes est le même, peu importe la manière dont elles ont été créées et l'endroit où elles sont stockées, dans le pool de chaînes ou dans une zone mémoire distincte. C'est pourquoi myString1 , myString2 et myString4 étaient égaux dans cette comparaison. Au fait, avez-vous remarqué que la méthode String equals() vous permet de comparer correctement des chaînes en respectant la casse ? Autrement dit, si nous comparons la chaîne "ma chaîne" avec les chaînes "Ma chaîne" et "MY STRING", nous obtenons faux.

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

   }
}

Le résultat est ici : Pour comparer des chaînes sans tenir compte de la casse, Java dispose d'une méthode très similaire à equals :

boolean equalsIgnoreCase​(String anotherString)

Utilisons-le dans notre exemple.

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

   }
}

Maintenant, le résultat est :