Classe StringUtils da Apache Commons

Introduzione a StringUtils

StringUtils è la classe Apache Commons più utilizzata. Contiene varie utilità e metodi che aiutano gli sviluppatori a evitare di scrivere standard o semplicemente codice ingombrante per le operazioni di base.

Molti dei metodi nella classe StringUtils hanno i loro equivalenti java.lang.String ma, a differenza dei metodi java.lang.String , sono null-safe. Ciò significa che una NullPointerException non viene generata nel momento più imprevisto.

Apache Commons contiene una serie di metodi e vedremo alcuni dei più comunemente usati.

Elenco dei metodi StringUtils:

StringUtils.isEmpty() e StringUtils.isBlank()

Entrambi i metodi vengono utilizzati per verificare se una stringa contiene del testo. Restituiscono vero se la stringa è veramente vuota. Inoltre, isBlank() restituirà vero anche se la stringa contiene solo spazi.

Hanno anche i propri metodi inversi: isNotEmpty() e isNotBlank() .

Vediamo come puoi usare isEmpty() insieme alla sua controparte java.lang.String.isEmpty() , così come isBlank() :

String nullValue = null;
String emptyValue = "";
String blankValue = "\n \t   \n";

if(StringUtils.isEmpty(emptyValue)) {
   System.out.println("emptyValue is emptyValue");
}

if(StringUtils.isBlank(blankValue)) {
   System.out.println("blankValue is blankValue");
}

if(!nullValue.isEmpty()) {
   System.out.println("nullString isn't null");
}

Ci sono tre variabili di tipo String qui . Uno punta a null , il secondo non è null ma non ha contenuto (una stringa vuota) e il terzo non è vuoto ma stamperà un risultato vuoto.

L'esecuzione di questo codice si traduce in:

emptyValue is emptyValue
blankValue is blankValue
Exception in thread "main" java.lang.NullPointerException

Il metodo isEmpty() incorporato in java.lang.String non è null safe . Otterrai facilmente una NullPointerException se provi a controllare se è vuota, perché chiami il metodo su un riferimento null . Sarà necessario verificare preventivamente se il riferimento è nullo:

String nullValue = null;
String emptyValue = "";
String blankValue = "\n \t   \n";

if(StringUtils.isEmpty(emptyValue)) {
   System.out.println("emptyValue is emptyValue");
}

if(StringUtils.isBlank(blankValue)) {
   System.out.println("blankValue is blankValue");
}

if(nullValue != null && !nullValue.isEmpty()) {
   System.out.println("nullString isn't null");
}

Ora questo si traduce in:

emptyValue is emptyValue
blankValue is blankValue

E se testiamo questi metodi sunullString:

String nullValue = null;

if(StringUtils.isEmpty(nullValue)) {
   System.out.println("nullValue is emptyValue");
}

if(StringUtils.isBlank(nullValue)) {
   System.out.println("nullValue is blankValue");
}

Quindi otteniamo:

nullValue is emptyValue
nullValue is blankValue

I metodi StringUtils sono null safe e producono il risultato previsto anche se vengono passati null .

StringUtils.equals()

Questo metodo confronta due stringhe e restituisce true se sono identiche o se entrambi i riferimenti puntano a null , ma tieni presente che questo metodo fa distinzione tra maiuscole e minuscole.

Vediamo come funziona:

System.out.println(StringUtils.equals(null, null));
System.out.println(StringUtils.equals(null, "some information"));
System.out.println(StringUtils.equals("some information", null));
System.out.println(StringUtils.equals("some information",  "some information"));
System.out.println(StringUtils.equals("some additional information", "some information"));

Risultato:

true
false
false
true
false

Per confrontare il metodo equals() da StringUtils con java.lang.String.equals() :

String nullValue = null;

System.out.println(StringUtils.equals(nullValue, null));
System.out.println(StringUtils.equals(nullValue, "some information"));

System.out.println(nullValue.equals(null));
System.out.println(nullValue.equals("some information"));

Questo ti riporta a:

true
false
Exception in thread "main" java.lang.NullPointerException

Ancora una volta, chiamando un metodo su un riferimento null si ottiene una NullPointerException e sarà necessario verificare se la variabile di riferimento è null prima di utilizzarla.

StringUtils.compare()

La dichiarazione di questo metodo è simile a questa:

public static int compare(final String str1, final String str2)

Questo metodo confronta lessicograficamente due stringhe, come fa il metodo java.lang.String.compareTo() , restituendo:

• 0 se str1 è uguale a str2 (o entrambi sono nulli)
• Il valore è minore di 0 se str1 è minore di str2
• Valore maggiore di 0 se str1 è maggiore di str2

L'ordine lessicografico è l'ordine del dizionario. Vediamo come possiamo usarlo nel nostro programma:

System.out.println(StringUtils.compare(null, null));
System.out.println(StringUtils.compare(null , "codeGym"));
System.out.println(StringUtils.compare("codeGym", null));
System.out.println(StringUtils.compare("codeGym", "CODEGYM"));
System.out.println(StringUtils.compare("codeGym", "codeGym"));

Noi abbiamo:

0
-1
1
32
0

Nota: un valore nullo è considerato minore di un valore non nullo . Due valori nulli sono considerati uguali.

Verifica se una stringa contiene un'altra sottostringa

Per fare questo, StringUtils ha 5 metodi:

• contiene()
• contieneIgnoreCase()
• contieneQualsiasi()
• contieneNessuno()
• contieneSolo()

Il metodo contains() restituisce true o false a seconda che la sequenza di ricerca sia contenuta o meno in un'altra sequenza.

Se null viene passato a tale metodo , restituirà false . Se non null viene passato , il metodo chiamerà semplicemente java.lang.String.indexOf(String str) sull'oggetto passato.

Esempi:

String value = "CodeGym is cool";

System.out.println(StringUtils.contains(null, "a"));
System.out.println(StringUtils.contains(value, "CodeGym"));
System.out.println(StringUtils.contains(value, "C++"));
System.out.println(StringUtils.contains(value, "codegym"));

Il metodo fa distinzione tra maiuscole e minuscole, quindi anche l'ultima chiamata restituirà false :

false
true
false
false

Il metodo containsAny() restituisce true se la stringa passata come primo argomento contiene almeno una delle sottostringhe passate negli argomenti 2-N.

Esempio:

String value = "CodeGym is cool";
System.out.println(StringUtils.containsAny(value, "cool", "c00l", "bro", "hello"));

Visualizzerà:

true

Anche questo metodo fa distinzione tra maiuscole e minuscole.

contieneNone() metodo

Quando è necessario verificare che una determinata stringa non contenga nulla della lista, è possibile utilizzare il metodo containsNone() . Il primo parametro è una stringa e i seguenti parametri sono stringhe che non devono trovarsi nel sink di destinazione.

Esempio:

String s = "CodeGym is cool";
System.out.println(StringUtils.containsNone(s, 'g', 'a'));

Uscita console:

false

Lavorare con le sottostringhe

Lavorare con le sottostringhe è simile a lavorare con i metodi della classe String :

substring(String str, int start)
substring (String str, int start, int end)

Questi metodi restituiscono una sottostringa dalla stringa str . La stringa è data da due indici: start e end . E come al solito in Java, l'ultimo carattere dell'intervallo è end-1 . Qual è il vantaggio di questi metodi?

Se passi null a tale metodo , restituirà semplicemente null invece di lanciare un'eccezione. Questi metodi supportano valori di indice negativi. In questo caso, la stringa è considerata come un anello chiuso. L'ultimo carattere è seguito dal primo e così via.

Vediamo come possiamo usarlo:

System.out.println(StringUtils.substring("lets java", 2, 6));
System.out.println(StringUtils.substring("lets java", -8));
System.out.println(StringUtils.substring(null, 3));

L'esecuzione del codice sopra ci dà:

ts j
ets java
null

StringUtils.split()

Un metodo che consente di dividere una stringa in sottostringhe utilizzando uno speciale carattere delimitatore. Se ce n'è uno nella stringa di destinazione, il metodo restituirà un array di sottostringhe. Se non è presente alcun carattere, verrà restituito un array vuoto. Bene, se null viene passato al metodo , restituirà null . Diamo un'occhiata a questo codice e a come funziona il metodo:

String myData = "Address, City, State, Zip, Phone, Email, Password";

System.out.println(Arrays.toString(StringUtils.split(myData, ',')));
System.out.println(Arrays.toString(StringUtils.split(null, '.')));
System.out.println(Arrays.toString(StringUtils.split("", '.')));

Risultato:

[Address,  City,  State,  Zip,  Phone,  Email,  Password]
null
[]

StringUtils.join()

Il metodo join() consente di concatenare un array di stringhe in un'unica stringa. Allo stesso tempo, gli può essere passato un carattere separatore speciale, che verrà aggiunto tra le sottostringhe nella stringa risultante. E se null viene passato al metodo , allora restituirà null .

Questo metodo è l'esatto opposto del metodo split() . Diamo un'occhiata a questo semplice esempio:

String myData = "Address, City, State, Zip, Phone, Email, Password";

String[] myString =  StringUtils.split(myData, ',');
System.out.println(StringUtils.join(myString, '-'));

L'esecuzione del codice sopra ci dà:

Address- City- State- Zip- Phone- Email- Password

StringUtils.replace()

Cerca una stringa all'interno di una stringa, la trova se esiste e ne sostituisce tutte le occorrenze con una nuova stringa.

La dichiarazione di questo metodo è simile a questa:

public static String replace(final String text, final String searchString, final String replacement)

Se la stringa di ricerca non viene trovata nel testo, non accadrà nulla e il testo rimarrà lo stesso. Seguendo la stessa logica, se il testo è null , questo metodo restituisce null . Se stai cercando una stringa nulla o sostituendo una sottostringa con null , il metodo restituirà la stringa originale.

Proviamo questo metodo:

String value = "CodeGym is the best";
System.out.println(StringUtils.replace(value, "best", "cool"));

Risultato:

CodeGym is the cool

• Guida alla classe StringUtils di Apache Commons in Java
• Apache Commons Java StringUtils Class Guide