Combinaison des vérifications de nullité et de chaîne vide
Dans l'étape précédente, nous avons appris à vérifier si une variable est null en utilisant l'opérateur ==. Cependant, en Java, surtout lorsqu'il s'agit d'objets String, il est souvent nécessaire de vérifier non seulement si une variable est null, mais aussi si elle est "vide". Une chaîne vide est un objet String qui existe mais ne contient aucun caractère (par exemple, ""). Une chaîne null, en revanche, signifie que la variable ne fait référence à aucun objet String du tout.
Tenter d'appeler des méthodes telles que isEmpty() ou length() sur une chaîne null entraînera une NullPointerException. Par conséquent, lorsque vous souhaitez traiter les chaînes null et les chaînes vides de la même manière (par exemple, les considérer comme "vides" ou "manquantes"), vous devez vérifier les deux conditions.
La méthode la plus courante pour faire cela consiste à vérifier d'abord si la chaîne est null, puis, si elle n'est pas null, de vérifier si elle est vide en utilisant la méthode isEmpty().
Modifions notre programme HelloJava.java pour illustrer la combinaison de ces vérifications.
-
Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.
-
Remplacez le code actuel par le suivant :
public class HelloJava {
public static void main(String[] args) {
String text1 = null;
String text2 = ""; // Une chaîne vide
String text3 = "Hello"; // Une chaîne non vide
System.out.println("Checking text1 (null):");
if (text1 == null || text1.isEmpty()) {
System.out.println("text1 is null or empty.");
} else {
System.out.println("text1 is not null and not empty: " + text1);
}
System.out.println("\nChecking text2 (empty):");
// Il est crucial de vérifier la nullité en premier !
if (text2 == null || text2.isEmpty()) {
System.out.println("text2 is null or empty.");
} else {
System.out.println("text2 is not null and not empty: " + text2);
}
System.out.println("\nChecking text3 (not empty):");
if (text3 == null || text3.isEmpty()) {
System.out.println("text3 is null or empty.");
} else {
System.out.println("text3 is not null and not empty: " + text3);
}
}
}
Dans ce code mis à jour :
- Nous introduisons trois variables
String : text1 (null), text2 (vide) et text3 (non vide).
- Nous utilisons l'opérateur logique OU (
||) pour combiner la vérification de nullité (text == null) et la vérification de chaîne vide (text.isEmpty()).
- La condition
text == null || text.isEmpty() sera vraie si text est null OU si text n'est pas null ET que text.isEmpty() est vrai.
- Important : La vérification de nullité (
text == null) doit être placée en premier dans la condition ||. Si text est null, la première partie de la condition || (text == null) est vraie, et Java utilise l'"évaluation paresseuse" pour sauter la deuxième partie (text.isEmpty()), évitant ainsi une NullPointerException. Si la vérification isEmpty() était placée en premier et que text était null, cela causerait une erreur.
-
Enregistrez le fichier (Ctrl+S ou Cmd+S).
-
Compilez le programme dans le terminal :
javac HelloJava.java
-
Exécutez le programme :
java HelloJava
Vous devriez voir la sortie suivante :
Checking text1 (null):
text1 is null or empty.
Checking text2 (empty):
text2 is null or empty.
Checking text3 (not empty):
text3 is not null and not empty: Hello
Cette sortie montre que notre vérification combinée a correctement identifié à la fois la chaîne null (text1) et la chaîne vide (text2) comme "null ou vide", tout en identifiant correctement la chaîne non vide (text3).
Cette vérification combinée (string == null || string.isEmpty()) est un modèle très courant en Java lorsque vous devez gérer à la fois les chaînes null et les chaînes vides. De nombreuses bibliothèques proposent également des méthodes utilitaires pour cela, telles que StringUtils.isEmpty() ou StringUtils.isBlank() (qui vérifie également les espaces blancs) dans Apache Commons Lang, mais il est essentiel de comprendre la vérification combinée de base.
