Comment vérifier si une chaîne de caractères est nulle en Java

Introduction

Dans ce laboratoire (lab), vous allez apprendre les techniques essentielles pour gérer les chaînes de caractères null en Java. Nous commencerons par explorer la méthode fondamentale de vérification de la nullité à l'aide de l'opérateur d'égalité (==), en comprenant pourquoi cela est crucial pour éviter la NullPointerException.

En nous appuyant sur cela, vous apprendrez à combiner les vérifications de nullité avec les vérifications de chaînes vides pour gérer efficacement les différents états des chaînes de caractères. Enfin, nous présenterons la classe Optional comme une approche moderne et plus sûre pour gérer les valeurs potentiellement nulles, en montrant comment elle peut améliorer la lisibilité du code et prévenir les erreurs courantes.

Tester la nullité à l'aide de l'opérateur d'égalité

Dans cette étape, nous allons apprendre à vérifier si une variable de type chaîne de caractères (string) en Java est null en utilisant l'opérateur d'égalité (==). Comprendre comment gérer les valeurs null est crucial en programmation Java pour éviter les erreurs.

En Java, une variable de type référence (comme String) peut contenir une valeur spéciale appelée null. Cela signifie que la variable ne fait référence à aucun objet en mémoire. Tenter d'utiliser une variable null comme si elle était un objet valide entraînera une NullPointerException, qui est une erreur courante et frustrante pour les débutants.

La manière la plus simple de vérifier si une chaîne de caractères est null consiste à utiliser l'opérateur d'égalité (==).

Créons un simple programme Java pour illustrer cela.

Ouvrez le WebIDE et assurez-vous que vous êtes dans le répertoire ~/project. Vous pouvez le vérifier en regardant l'invite de commande du terminal ou en tapant pwd puis en appuyant sur Entrée.
Créez un nouveau fichier Java nommé NullCheck.java dans le répertoire ~/project. Vous pouvez le faire en cliquant avec le bouton droit dans l'explorateur de fichiers à gauche, en sélectionnant "Nouveau fichier" et en tapant NullCheck.java.

Ouvrez le fichier NullCheck.java dans l'éditeur et collez le code suivant :

public class NullCheck {

    public static void main(String[] args) {

        String myString1 = "Hello";
        String myString2 = null;
        String myString3 = ""; // This is an empty string, not null

        System.out.println("Checking myString1:");
        if (myString1 == null) {
            System.out.println("myString1 is null");
        } else {
            System.out.println("myString1 is not null");
        }

        System.out.println("\nChecking myString2:");
        if (myString2 == null) {
            System.out.println("myString2 is null");
        } else {
            System.out.println("myString2 is not null");
        }

        System.out.println("\nChecking myString3:");
        if (myString3 == null) {
            System.out.println("myString3 is null");
        } else {
            System.out.println("myString3 is not null");
        }
    }
}

Dans ce code :

Nous déclarons trois variables de type String : myString1 est affectée à une chaîne de caractères normale, myString2 est explicitement affectée à null, et myString3 est affectée à une chaîne de caractères vide ("").
Nous utilisons une instruction if avec l'opérateur d'égalité (==) pour vérifier si chaque chaîne de caractères est null.
Nous affichons un message indiquant si la chaîne de caractères est null ou non.

Enregistrez le fichier NullCheck.java (Ctrl+S ou Cmd+S).
Ouvrez le terminal en bas du WebIDE. Assurez-vous que vous êtes dans le répertoire ~/project.
Compilez le programme Java en utilisant la commande javac :
```
javac NullCheck.java
```
S'il n'y a pas d'erreurs, cette commande créera un fichier NullCheck.class dans le même répertoire.

Exécutez le programme Java compilé en utilisant la commande java :

java NullCheck

Vous devriez voir une sortie similaire à ceci :

Checking myString1:
myString1 is not null

Checking myString2:
myString2 is null

Checking myString3:
myString3 is not null

Cette sortie confirme que myString1 et myString3 ne sont pas null, tandis que myString2 est null. Il est important de noter la différence entre une chaîne de caractères null et une chaîne de caractères vide (""). Une chaîne de caractères vide est un objet String valide avec zéro caractères, tandis qu'une variable de chaîne de caractères null ne pointe vers aucun objet.

Utiliser == null est la manière standard et correcte de vérifier si une variable de référence est null en Java.

Combiner les vérifications de nullité et de chaîne vide

Dans l'étape précédente, nous avons appris à vérifier si une chaîne de caractères est null. Cependant, dans de nombreux cas pratiques, vous devrez peut-être également vérifier si une chaîne de caractères est vide (ne contient aucun caractère) ou ne contient que des espaces blancs. Une chaîne de caractères qui est null, vide ou ne contient que des espaces blancs est souvent considérée comme "vide" ou "effectivement vide".

Vérifier à la fois la nullité et la vacuité d'une chaîne de caractères est une exigence courante. Vous pouvez combiner ces vérifications en utilisant l'opérateur logique OU (||).

Modifions notre programme précédent pour inclure des vérifications à la fois de la nullité et de la vacuité des chaînes de caractères.

Ouvrez le fichier NullCheck.java dans l'éditeur du WebIDE.

Modifiez la méthode main pour inclure une chaîne de caractères vide et combiner les vérifications. Remplacez la méthode main existante par le code suivant :

public class NullCheck {

    public static void main(String[] args) {

        String myString1 = "Hello";
        String myString2 = null;
        String myString3 = ""; // This is an empty string
        String myString4 = "   "; // This string contains only whitespace

        System.out.println("Checking myString1:");
        if (myString1 == null || myString1.isEmpty()) {
            System.out.println("myString1 is null or empty");
        } else {
            System.out.println("myString1 is not null and not empty");
        }

        System.out.println("\nChecking myString2:");
        if (myString2 == null || myString2.isEmpty()) {
            System.out.println("myString2 is null or empty");
        } else {
            System.out.println("myString2 is not null and not empty");
        }

        System.out.println("\nChecking myString3:");
        if (myString3 == null || myString3.isEmpty()) {
            System.out.println("myString3 is null or empty");
        } else {
            System.out.println("myString3 is not null and not empty");
        }

        System.out.println("\nChecking myString4:");
        // Note: isEmpty() does not check for whitespace
        if (myString4 == null || myString4.isEmpty()) {
            System.out.println("myString4 is null or empty");
        } else {
            System.out.println("myString4 is not null and not empty");
        }
    }
}

Dans ce code mis à jour :

Nous avons ajouté myString4 qui ne contient que des espaces blancs.
Nous utilisons la condition myString == null || myString.isEmpty() pour vérifier si une chaîne de caractères est soit null, soit vide. La méthode isEmpty() est une méthode intégrée de la classe String qui renvoie true si la chaîne de caractères a une longueur de 0.
Important : La méthode isEmpty() ne peut être appelée que sur une chaîne de caractères non nulle. Si vous essayez d'appeler isEmpty() sur une chaîne de caractères null, vous obtiendrez une NullPointerException. Par conséquent, il est crucial de vérifier d'abord la nullité en utilisant myString == null avant d'appeler myString.isEmpty(). L'opérateur logique OU (||) est "court-circuité", ce qui signifie que si la première condition (myString == null) est vraie, la deuxième condition (myString.isEmpty()) n'est pas évaluée, évitant ainsi la NullPointerException.

Enregistrez le fichier NullCheck.java.
Compilez le programme modifié dans le terminal :
```
javac NullCheck.java
```

Exécutez le programme compilé :

java NullCheck

Vous devriez voir une sortie similaire à ceci :

Checking myString1:
myString1 is not null and not empty

Checking myString2:
myString2 is null or empty

Checking myString3:
myString3 is null or empty

Checking myString4:
myString4 is not null and not empty

Notez que myString4 (qui ne contient que des espaces blancs) est considérée comme "non nulle et non vide" par cette vérification. Si vous devez également considérer les chaînes de caractères ne contenant que des espaces blancs comme "vides", vous pouvez utiliser la méthode isBlank() (disponible depuis Java 11).

Mettons rapidement à jour le code pour utiliser isBlank() pour myString4 :

Modifiez la vérification pour myString4 dans NullCheck.java :

// ... (previous code) ...

        System.out.println("\nChecking myString4 with isBlank():");
        if (myString4 == null || myString4.isBlank()) {
            System.out.println("myString4 is null or blank");
        } else {
            System.out.println("myString4 is not null and not blank");
        }
    }
}

Enregistrez le fichier, compilez-le et exécutez-le à nouveau :
```
javac NullCheck.java
java NullCheck
```
La sortie pour myString4 devrait maintenant être :
```
Checking myString4 with isBlank():
myString4 is null or blank
```

Cela démontre comment combiner les vérifications de nullité et de chaîne vide/ne contenant que des espaces blancs, ce qui est un modèle très courant en programmation Java.

Utiliser Optional pour gérer en toute sécurité les chaînes de caractères nulles

Dans les étapes précédentes, nous avons utilisé l'opérateur d'égalité (==) et les méthodes isEmpty() ou isBlank() pour vérifier les chaînes de caractères null et vides/ne contenant que des espaces blancs. Bien que ces méthodes soient efficaces, Java 8 a introduit la classe Optional pour gérer les valeurs potentiellement null de manière plus explicite et fonctionnelle. L'utilisation de Optional peut rendre votre code plus lisible et moins sujet aux NullPointerException.

Optional est un objet conteneur qui peut contenir une valeur non nulle ou pas. Si une valeur est présente, isPresent() renverra true et get() renverra la valeur. Si aucune valeur n'est présente, l'objet est considéré comme vide et isPresent() renverra false. Appeler get() sur un Optional vide lancera une NoSuchElementException.

Explorons comment utiliser Optional avec des chaînes de caractères.

Ouvrez le fichier NullCheck.java dans l'éditeur du WebIDE.

Remplacez tout le contenu du fichier par le code suivant qui utilise Optional :

import java.util.Optional;

public class NullCheck {

    public static void main(String[] args) {

        String myString1 = "Hello";
        String myString2 = null;
        String myString3 = "";
        String myString4 = "   ";

        // Creating Optional objects from strings
        Optional<String> optionalString1 = Optional.ofNullable(myString1);
        Optional<String> optionalString2 = Optional.ofNullable(myString2);
        Optional<String> optionalString3 = Optional.ofNullable(myString3);
        Optional<String> optionalString4 = Optional.ofNullable(myString4);

        System.out.println("Checking optionalString1:");
        if (optionalString1.isPresent()) {
            System.out.println("optionalString1 has a value: " + optionalString1.get());
        } else {
            System.out.println("optionalString1 is empty (contains null)");
        }

        System.out.println("\nChecking optionalString2:");
        if (optionalString2.isPresent()) {
            System.out.println("optionalString2 has a value: " + optionalString2.get());
        } else {
            System.out.println("optionalString2 is empty (contains null)");
        }

        System.out.println("\nChecking optionalString3:");
        // Optional.ofNullable("") creates an Optional containing an empty string
        if (optionalString3.isPresent()) {
            System.out.println("optionalString3 has a value: " + optionalString3.get());
        } else {
            System.out.println("optionalString3 is empty (contains null)");
        }

        System.out.println("\nChecking optionalString4:");
         if (optionalString4.isPresent()) {
            System.out.println("optionalString4 has a value: " + optionalString4.get());
        } else {
            System.out.println("optionalString4 is empty (contains null)");
        }

        // Using Optional methods for safer handling
        System.out.println("\nUsing Optional methods:");

        // orElse: provides a default value if the Optional is empty
        String value1 = optionalString1.orElse("Default Value");
        String value2 = optionalString2.orElse("Default Value");
        System.out.println("Value from optionalString1 (orElse): " + value1);
        System.out.println("Value from optionalString2 (orElse): " + value2);

        // ifPresent: performs an action if a value is present
        System.out.print("If optionalString1 is present: ");
        optionalString1.ifPresent(s -> System.out.println("Value is " + s));

        System.out.print("If optionalString2 is present: ");
        optionalString2.ifPresent(s -> System.out.println("Value is " + s));

        // filter: filters the value if present
        System.out.print("Filtered optionalString1 (length > 3): ");
        optionalString1.filter(s -> s.length() > 3).ifPresent(s -> System.out.println("Value is " + s));

        System.out.print("Filtered optionalString3 (length > 3): ");
        optionalString3.filter(s -> s.length() > 3).ifPresent(s -> System.out.println("Value is " + s));
    }
}

Dans ce code :

Nous importons la classe Optional.
Nous utilisons Optional.ofNullable(string) pour créer un Optional<String> à partir d'une String normale. Cette méthode peut être utilisée en toute sécurité même si la chaîne de caractères d'entrée est null. Si l'entrée est null, elle renvoie un Optional vide ; sinon, elle renvoie un Optional contenant la chaîne de caractères.
Nous utilisons optionalString.isPresent() pour vérifier si l'Optional contient une valeur.
Nous utilisons optionalString.get() pour récupérer la valeur si elle est présente. Attention : appeler get() sur un Optional vide lancera une exception, donc vérifiez toujours isPresent() d'abord ou utilisez d'autres méthodes plus sûres.
Nous démontrons orElse(defaultValue) qui renvoie la valeur contenue si elle est présente, sinon renvoie la valeur par défaut spécifiée.
Nous démontrons ifPresent(consumer) qui exécute le consommateur donné (une fonction qui prend un argument et ne renvoie aucun résultat) si une valeur est présente.
Nous démontrons filter(predicate) qui renvoie un Optional contenant la valeur si elle est présente et correspond au prédicat donné (une fonction qui renvoie un booléen), sinon renvoie un Optional vide.

Enregistrez le fichier NullCheck.java.
Compilez le programme dans le terminal :
```
javac NullCheck.java
```

Exécutez le programme :

java NullCheck

Vous devriez voir une sortie similaire à ceci :

Checking optionalString1:
optionalString1 has a value: Hello

Checking optionalString2:
optionalString2 is empty (contains null)

Checking optionalString3:
optionalString3 has a value:

Checking optionalString4:
optionalString4 has a value:

Using Optional methods:
Value from optionalString1 (orElse): Hello
Value from optionalString2 (orElse): Default Value
If optionalString1 is present: Value is Hello
If optionalString2 is present:
Filtered optionalString1 (length > 3): Value is Hello
Filtered optionalString3 (length > 3):

L'utilisation de Optional peut rendre votre code plus expressif quant à la possibilité d'absence d'une valeur et fournit des méthodes utiles pour gérer la présence ou l'absence d'une valeur sans vérifications explicites de null partout. Bien que Optional soit un outil puissant, il n'est pas un remplacement pour toutes les vérifications de null, mais il est particulièrement utile lorsqu'il s'agit de gérer des valeurs de retour qui pourraient être null.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si une chaîne de caractères en Java est null. Nous avons commencé par utiliser l'opérateur d'égalité (==) pour comparer directement une variable de chaîne de caractères avec null, en comprenant que null signifie l'absence de référence d'objet et que le fait de ne pas vérifier la nullité peut entraîner une NullPointerException.

Nous avons ensuite exploré comment combiner la vérification de la nullité avec une vérification de chaîne de caractères vide, en reconnaissant qu'une chaîne de caractères vide ("") est un objet valide, contrairement à null. Enfin, nous avons appris à utiliser la classe Optional, introduite en Java 8, comme une méthode plus moderne et plus sûre pour gérer les valeurs potentiellement nulles, favorisant ainsi un code plus robuste et plus lisible en indiquant explicitement la possibilité d'une valeur manquante.