Confronto di stringhe in Java

1. Panoramica

In questo articolo parleremo dei diversi modi di confrontare le stringhe in Java.

Poiché String è uno dei tipi di dati più utilizzati in Java, questa è naturalmente un'operazione molto comunemente utilizzata.

2. String Confronto Con String Classe

2.1. Utilizzo dell'operatore di confronto "=="

L'utilizzo dell'operatore "==" per confrontare i valori di testo è uno degli errori più comuni commessi dai principianti di Java. Questo non è corretto perché "==" controlla solo l'uguaglianza referenziale di due stringhe , ovvero se fanno riferimento allo stesso oggetto o meno.

Vediamo un esempio di questo comportamento:

String string1 = "using comparison operator"; String string2 = "using comparison operator"; String string3 = new String("using comparison operator"); assertThat(string1 == string2).isTrue(); assertThat(string1 == string3).isFalse();

Nell'esempio sopra, la prima asserzione è vera perché le due variabili puntano allo stesso valore letterale String .

D'altra parte, la seconda asserzione è falsa perché stringa1 viene creata con un letterale e stringa3 viene creata utilizzando l' operatore new , quindi fanno riferimento a oggetti diversi.

2.2. Utilizzo di uguale ()

La classe String sovrascrive l' equals () ereditato da Object. Questo metodo confronta due stringhe carattere per carattere, ignorando il loro indirizzo.

Li considera uguali se hanno la stessa lunghezza ei caratteri sono nello stesso ordine:

String string1 = "using equals method"; String string2 = "using equals method"; String string3 = "using EQUALS method"; String string4 = new String("using equals method"); assertThat(string1.equals(string2)).isTrue(); assertThat(string1.equals(string4)).isTrue(); assertThat(string1.equals(null)).isFalse(); assertThat(string1.equals(string3)).isFalse();

In questo esempio, le variabili stringa1, stringa2 e stringa4 sono uguali perché hanno lo stesso valore e maiuscolo indipendentemente dal loro indirizzo.

Per string3 il metodo restituisce false, poiché distingue tra maiuscole e minuscole.

Inoltre, se una delle due stringhe è null , il metodo restituisce false.

2.3. Utilizzo di equalsIgnoreCase ()

Il metodo equalsIgnoreCase () restituisce un valore booleano. Come suggerisce il nome, questo metodo ignora il maiuscolo / minuscolo nei caratteri durante il confronto delle stringhe :

String string1 = "using equals ignore case"; String string2 = "USING EQUALS IGNORE CASE"; assertThat(string1.equalsIgnoreCase(string2)).isTrue();

2.4. Utilizzando compareTo ()

Il metodo compareTo () restituisce un valore di tipo int e confronta due stringhe carattere per carattere lessicograficamente sulla base di un dizionario o di un ordinamento naturale.

Questo metodo restituisce 0 se due stringhe sono uguali o se entrambe sono null, un numero negativo se la prima stringa viene prima dell'argomento e un numero maggiore di zero se la prima stringa viene dopo l'argomento String.

Vediamo un esempio:

String author = "author"; String book = "book"; String duplicateBook = "book"; assertThat(author.compareTo(book)) .isEqualTo(-1); assertThat(book.compareTo(author)) .isEqualTo(1); assertThat(duplicateBook.compareTo(book)) .isEqualTo(0);

2.5. Utilizzo di compareToIgnoreCase ()

Il compareToIgnoreCase () è simile al metodo precedente, tranne che ignora le maiuscole e le minuscole:

String author = "Author"; String book = "book"; String duplicateBook = "BOOK"; assertThat(author.compareToIgnoreCase(book)) .isEqualTo(-1); assertThat(book.compareToIgnoreCase(author)) .isEqualTo(1); assertThat(duplicateBook.compareToIgnoreCase(book)) .isEqualTo(0);

3. Confronto di stringhe con la classe di oggetti

Objects è una classe di utilità che contiene un metodo statico equals () , utile in questo scenario - per confrontare due stringhe.

Il metodo restituisce true se due stringhe sono uguali confrontandole prima utilizzando il loro indirizzo, ovvero " ==" . Di conseguenza, se entrambi gli argomenti sono nulli , restituisce true e se esattamente un argomento è nullo , restituisce false.

Altrimenti, chiama semplicemente il metodo equals () della classe del tipo dell'argomento passato, che nel nostro caso è il metodo equals () della classe di String . Questo metodo distingue tra maiuscole e minuscole perché chiama internamente il metodo equals () della classe String .

Proviamo questo:

String string1 = "using objects equals"; String string2 = "using objects equals"; String string3 = new String("using objects equals"); assertThat(Objects.equals(string1, string2)).isTrue(); assertThat(Objects.equals(string1, string3)).isTrue(); assertThat(Objects.equals(null, null)).isTrue(); assertThat(Objects.equals(null, string1)).isFalse();

4. Confronto di stringhe con Apache Commons

La libreria Apache Commons contiene una classe di utilità chiamato StringUtils per String- operazioni correlate ; questo ha anche alcuni metodi molto utili per il confronto delle stringhe .

4.1. Utilizzo di equals () ed equalsIgnoreCase ()

Il metodo equals () della classe StringUtils è una versione migliorata del metodo della classe String equals (), che gestisce anche i valori nulli:

assertThat(StringUtils.equals(null, null)) .isTrue(); assertThat(StringUtils.equals(null, "equals method")) .isFalse(); assertThat(StringUtils.equals("equals method", "equals method")) .isTrue(); assertThat(StringUtils.equals("equals method", "EQUALS METHOD")) .isFalse();

Il metodo equalsIgnoreCase () di StringUtils restituisce un valore booleano . Funziona in modo simile a equals (), tranne per il fatto che ignora l'involucro dei caratteri in Stringhe:

assertThat(StringUtils.equalsIgnoreCase("equals method", "equals method")) .isTrue(); assertThat(StringUtils.equalsIgnoreCase("equals method", "EQUALS METHOD")) .isTrue();

4.2. Utilizzo di equalsAny () ed equalsAnyIgnoreCase ()

Il primo argomento del metodo equalsAny () è una stringa e il secondo è un tipo CharSequence con più argomenti. Il metodo restituisce true se una qualsiasi delle altre stringhe fornite corrisponde al primo caso String in modo sensibile.

In caso contrario, viene restituito false:

assertThat(StringUtils.equalsAny(null, null, null)) .isTrue(); assertThat(StringUtils.equalsAny("equals any", "equals any", "any")) .isTrue(); assertThat(StringUtils.equalsAny("equals any", null, "equals any")) .isTrue(); assertThat(StringUtils.equalsAny(null, "equals", "any")) .isFalse(); assertThat(StringUtils.equalsAny("equals any", "EQUALS ANY", "ANY")) .isFalse();

Il metodo equalsAnyIgnoreCase () funziona in modo simile al metodo equalsAny () , ma ignora anche le maiuscole :

assertThat(StringUtils.equalsAnyIgnoreCase("ignore case", "IGNORE CASE", "any")).isTrue();

4.3. Usare compare () e compareIgnoreCase ()

Il metodo compare () nella classe StringUtils è una versione null-safe del metodo compareTo () della classe String e gestisce i valori nulli considerando un valore nullo inferiore a un valore non nullo . Due valori nulli sono considerati uguali.

Inoltre, questo metodo può essere utilizzato per ordinare un elenco di stringhe con voci nulle :

assertThat(StringUtils.compare(null, null)) .isEqualTo(0); assertThat(StringUtils.compare(null, "abc")) .isEqualTo(-1); assertThat(StringUtils.compare("abc", "bbc")) .isEqualTo(-1); assertThat(StringUtils.compare("bbc", "abc")) .isEqualTo(1);

Il metodo compareIgnoreCase () si comporta in modo simile, tranne che ignora le maiuscole:

assertThat(StringUtils.compareIgnoreCase("Abc", "bbc")) .isEqualTo(-1); assertThat(StringUtils.compareIgnoreCase("bbc", "ABC")) .isEqualTo(1); assertThat(StringUtils.compareIgnoreCase("abc", "ABC")) .isEqualTo(0);

I due metodi possono essere utilizzati anche con un'opzione nullIsLess . Questo è un terzo argomento booleano che decide se i valori nulli devono essere considerati minori o meno .

Un valore null è inferiore a un altro String se nullIsLess è true e maggiore se nullIsLess è false.

Proviamolo:

assertThat(StringUtils.compare(null, "abc", true)) .isEqualTo(-1); assertThat(StringUtils.compare(null, "abc", false)) .isEqualTo(1);

Il metodo compareIgnoreCase () con un terzo argomento booleano funziona in modo simile, tranne che ignorando il caso.

5. conclusione

In questo breve tutorial, abbiamo discusso diversi modi di confrontare le stringhe.

E, come sempre, il codice sorgente per gli esempi può essere trovato su GitHub.