Classe StringUtils d'Apache Commons

Introduction à StringUtils

StringUtils est la classe Apache Commons la plus utilisée. Il contient divers utilitaires et méthodes qui aident les développeurs à éviter d'écrire du code passe-partout ou simplement du code peu maniable pour les opérations de base.

De nombreuses méthodes de la classe StringUtils ont leurs équivalents java.lang.String mais, contrairement aux méthodes java.lang.String , sont null-safe. Cela signifie qu'une NullPointerException n'est pas levée au moment le plus inattendu.

Apache Commons contient un certain nombre de méthodes, et nous examinerons certaines des plus couramment utilisées.

Liste des méthodes StringUtils :

StringUtils.isEmpty() et StringUtils.isBlank()

Les deux méthodes sont utilisées pour vérifier si une chaîne contient du texte. Ils retournent vrai si la chaîne est vraiment vide. De plus, isBlank() renverra également true si la chaîne ne contient que des espaces.

Ils ont également leurs propres méthodes inverses : isNotEmpty() et isNotBlank() .

Voyons comment vous pouvez utiliser isEmpty() avec son homologue java.lang.String.isEmpty() , ainsi que 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");
}

Il y a trois variables de type String ici . L'un pointe vers null , le second n'est pas null mais n'a pas de contenu (une chaîne vide), et le troisième n'est pas vide mais imprimera un résultat vide.

L'exécution de ce code donne :

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

La méthode isEmpty() intégrée à java.lang.String n'est pas null safe . Vous obtiendrez facilement une NullPointerException si vous essayez de vérifier si elle est vide, car vous appelez la méthode sur une référence null . Il faudra vérifier au préalable si la référence est nulle :

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

Maintenant, cela se traduit par :

emptyValue is emptyValue
blankValue is blankValue

Et si nous testons ces méthodes surnullString:

String nullValue = null;

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

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

Alors on obtient :

nullValue is emptyValue
nullValue is blankValue

Les méthodes StringUtils sont null safe et produisent le résultat attendu même si elles sont passées null .

StringUtils.equals()

Cette méthode compare deux chaînes et renvoie true si elles sont identiques ou si les deux références pointent vers null , mais sachez que cette méthode est sensible à la casse.

Voyons voir comment ça fonctionne:

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

Résultat:

true
false
false
true
false

Pour comparer la méthode equals() de StringUtils avec 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"));

Cela vous ramène à :

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

Encore une fois, l'appel d'une méthode sur une référence null entraîne une NullPointerException , et vous devrez vérifier si la variable de référence est null avant de l'utiliser.

StringUtils.compare()

La déclaration de cette méthode ressemble à ceci :

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

Cette méthode compare deux chaînes de manière lexicographique, comme le fait la méthode java.lang.String.compareTo() , en retournant :

• 0 si str1 est égal à str2 (ou les deux sont nuls)
• La valeur est inférieure à 0 si str1 est inférieur à str2
• Valeur supérieure à 0 si str1 est supérieur à str2

L'ordre lexicographique est l'ordre du dictionnaire. Voyons comment nous pouvons l'utiliser dans notre programme :

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

On a:

0
-1
1
32
0

Remarque : Une valeur nulle est considérée comme inférieure à une valeur non nulle . Deux valeurs nulles sont considérées comme égales.

Vérifier si une chaîne contient une autre sous-chaîne

Pour ce faire, StringUtils dispose de 5 méthodes :

• contient()
• contientIgnoreCase()
• contientTout()
• contientAucun()
• contientSeul()

La méthode contains() renvoie vrai ou faux selon que la séquence de recherche est contenue dans une autre séquence ou non.

Si null est passé à une telle méthode , elle renverra false . Si non- null est passé , la méthode appellera simplement java.lang.String.indexOf(String str) sur l'objet passé.

Exemples:

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

La méthode est sensible à la casse, donc le dernier appel renverra également false :

false
true
false
false

La méthode containsAny() renvoie true si la chaîne passée en premier argument contient au moins une des sous-chaînes passées dans les arguments 2-N.

Exemple:

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

Affichera:

true

Cette méthode est également sensible à la casse.

méthode containsNone()

Lorsque vous devez vérifier qu'une certaine chaîne ne contient rien de la liste, vous pouvez utiliser la méthode containsNone() . Le premier paramètre est une chaîne et les paramètres suivants sont des chaînes qui ne doivent pas se trouver dans le récepteur cible.

Exemple:

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

Sortie console :

false

Travailler avec des sous-chaînes

Travailler avec des sous-chaînes est similaire à travailler avec des méthodes de la classe String :

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

Ces méthodes renvoient une sous-chaîne à partir de la chaîne str . La chaîne est donnée par deux indices : start et end . Et comme d'habitude en Java, le dernier caractère de la plage est end-1 . Quel est l'avantage de ces méthodes ?

Si vous passez null à une telle method , elle renverra simplement null au lieu de lever une exception. Ces méthodes prennent en charge les valeurs d'index négatives. Dans ce cas, la chaîne est considérée comme une boucle fermée. Le dernier caractère est suivi du premier, et ainsi de suite.

Voyons comment nous pouvons l'utiliser :

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'exécution du code ci-dessus nous donne:

ts j
ets java
null

StringUtils.split()

Une méthode qui vous permet de diviser une chaîne en sous-chaînes à l'aide d'un caractère délimiteur spécial. S'il y en a une dans la chaîne cible, la méthode renverra un tableau de sous-chaînes. S'il n'y a pas de caractère, un tableau vide sera retourné. Eh bien, si null est passé à la method , elle renverra null . Jetons un coup d'œil à ce code et au fonctionnement de la méthode :

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("", '.')));

Résultat:

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

StringUtils.join()

La méthode join() vous permet de concaténer un tableau de chaînes en une seule chaîne. En même temps, un caractère de séparation spécial peut lui être passé, qui sera ajouté entre les sous-chaînes dans la chaîne résultante. Et si null est passé à la méthode , elle renverra null .

Cette méthode est l'exact opposé de la méthode split() . Regardons cet exemple simple :

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

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

L'exécution du code ci-dessus nous donne:

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

StringUtils.replace()

Recherche une chaîne dans une chaîne, la trouve si elle existe et remplace toutes ses occurrences par une nouvelle chaîne.

La déclaration de cette méthode ressemble à ceci :

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

Si la chaîne de recherche n'est pas trouvée dans le texte, rien ne se passera et le texte restera le même. Suivant la même logique, si le texte est null , cette méthode renvoie null . Si vous recherchez une chaîne nulle ou remplacez une sous-chaîne par null , la méthode renverra la chaîne d'origine.

Essayons cette méthode :

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

Résultat:

CodeGym is the cool

• Guide de la classe StringUtils d'Apache Commons en Java
• Guide de classe Apache Commons Java StringUtils