La stringa Java è uguale a()

Il confronto degli oggetti per l'equivalenza è una delle operazioni di programmazione più importanti. Tuttavia, nonostante tutta la sua ovvietà nel mondo numerico, non è sempre chiaro come confrontare altri tipi di dati. La classe Java Object , di base, definisce i metodi equals() e compareTo() per il confronto. La classe String sovrascrive il suo metodo equals() . Il metodo Java String equals() confronta due stringhe in base al loro contenuto. La firma del metodo String equals() è simile alla seguente:

public boolean equals(Object anotherObject)

Il metodo String equals() confronta la stringa con l'oggetto specificato. Se le stringhe sono uguali restituisce vero, altrimenti è falso. Forse ti starai chiedendo perché non confrontare le stringhe utilizzando l' operatore di confronto == ? In effetti, anche questo è possibile, ma il risultato sarà leggermente diverso. Il fatto è che l' operatore == confronta gli indirizzi in memoria. Quindi se s1 == s2 restituisce true , queste due stringhe hanno lo stesso indirizzo in memoria. Allo stesso tempo, equals controlla l'uguaglianza del contenuto delle stringhe. Facciamo un esempio di confronto di due stringhe.

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

   }
}

L'output di questo programma è: Diamo uno sguardo più da vicino a cosa sta succedendo qui. Quando creiamo una stringa, questa viene inserita nello string pool, un'area speciale della memoria. Le stringhe occupano una parte enorme di tutti gli oggetti in qualsiasi programma di grandi dimensioni. Quindi per risparmiare memoria è stato creato String Pool, dove viene posizionata una stringa con il testo che ti serve. I collegamenti successivamente creati si riferiscono alla stessa area di memoria, non è necessario allocare memoria aggiuntiva ogni volta. Se crei una stringa senza l'operatore new, cioè quando scrivi

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

o qualcosa del genere, il programma controlla se c'è una stringa con tale testo nel pool di stringhe. In caso affermativo, non verrà creata alcuna nuova stringa . E il nuovo collegamento punterà allo stesso indirizzo nello String Pool in cui quella stringa è già archiviata. Quindi quando abbiamo scritto nel programma

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

il riferimento myString1 punta esattamente allo stesso posto in memoria di myString2 . Il primo comando creava una nuova stringa nello String Pool con il testo di cui avevamo bisogno e, quando si arrivava al secondo, si riferiva semplicemente alla stessa area di memoria di myString1 . Ma la stringa myString4 è stata creata come oggetto utilizzando l'operatore new . Questo operatore alloca una nuova area di memoria per un oggetto quando viene creato. Una stringa creata con new

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

non rientra nello String Pool, ma diventa un oggetto separato, anche se il suo testo corrisponde completamente alla stessa stringa dello String Pool. Inoltre, se confrontiamo le stringhe utilizzando il metodo String equals() , non controllerà l'indirizzo, ma il contenuto della stringa, la sequenza di caratteri nelle stringhe. E se il testo nelle stringhe è lo stesso, non importa come sono state create e dove sono archiviate, nello String Pool o in un'area di memoria separata. Ecco perché myString1 , myString2 e myString4 erano uguali in questo confronto. A proposito, hai notato che il metodo String equals() ti consente di confrontare correttamente le stringhe facendo distinzione tra maiuscole e minuscole? Cioè, se confrontiamo la stringa "my string" con le stringhe "My string" e "MY STRING" otteniamo false.

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

   }
}

L'output è qui: Per confrontare le stringhe senza distinzione tra maiuscole e minuscole, Java ha un metodo molto simile a equals :

boolean equalsIgnoreCase​(String anotherString)

Usiamolo nel nostro esempio.

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

   }
}

Ora l'output è: