Comment vérifier si un booléen est null en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à gérer en toute sécurité les valeurs null lors de l'utilisation d'objets Boolean en Java. Nous explorerons les pièges potentiels liés à l'exception NullPointerException lorsque l'on manipule la classe wrapper Boolean par rapport au type primitif boolean.

Vous apprendrez la bonne manière de vérifier si un objet Boolean est null avant d'accéder à sa valeur, utiliserez la classe Optional pour une gestion plus robuste des valeurs null, et comprendrez les principales différences de comportement en cas de valeur null entre le type primitif boolean et la classe wrapper Boolean grâce à des exemples pratiques.

Vérifier si un objet Boolean est null

Dans cette étape, nous allons explorer comment gérer les valeurs null potentielles lors de l'utilisation d'objets Boolean en Java. Contrairement aux types primitifs boolean qui sont toujours true ou false, la classe wrapper Boolean peut contenir une valeur null. Cela est une source courante d'erreurs NullPointerException si cela n'est pas géré avec soin.

Créons un simple programme Java pour illustrer cela.

Ouvrez l'éditeur WebIDE.
Dans l'explorateur de fichiers à gauche, assurez-vous d'être dans le répertoire ~/project.
Cliquez avec le bouton droit dans l'espace vide de l'explorateur de fichiers, sélectionnez "Nouveau fichier" et nommez-le BooleanCheck.java.
Ouvrez le fichier BooleanCheck.java dans l'éditeur.

Copiez et collez le code suivant dans l'éditeur :

public class BooleanCheck {
    public static void main(String[] args) {
        Boolean myBoolean = null;

        // This will cause a NullPointerException if myBoolean is null
        // if (myBoolean) {
        //     System.out.println("myBoolean is true");
        // }

        // Correct way to check for null before accessing the boolean value
        if (myBoolean != null && myBoolean) {
            System.out.println("myBoolean is true");
        } else if (myBoolean == null) {
            System.out.println("myBoolean is null");
        } else {
            System.out.println("myBoolean is false");
        }
    }
}

Dans ce code :

Nous déclarons un objet Boolean nommé myBoolean et l'initialisons à null.
La ligne if (myBoolean) mise en commentaire montre une erreur courante qui entraîne une NullPointerException lorsque myBoolean est null.
La ligne if (myBoolean != null && myBoolean) montre la bonne manière de vérifier si l'objet Boolean n'est pas null avant d'essayer d'évaluer sa valeur booléenne. L'opérateur && est un opérateur de court-circuit, ce qui signifie que si myBoolean != null est faux, la deuxième partie (myBoolean) n'est pas évaluée, évitant ainsi l'erreur.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Ouvrez le terminal en bas de l'éditeur WebIDE. Assurez-vous d'être dans le répertoire ~/project en utilisant la commande cd ~/project.
Compilez le programme Java en tapant la commande suivante et en appuyant sur Entrée :
```
javac BooleanCheck.java
```
S'il n'y a pas d'erreurs, vous ne verrez aucun résultat. Un fichier BooleanCheck.class sera créé dans le répertoire ~/project.
Exécutez le programme compilé en utilisant la commande suivante et en appuyant sur Entrée :
```
java BooleanCheck
```
Vous devriez voir le résultat suivant :
```
myBoolean is null
```

Ce résultat confirme que notre programme a correctement identifié que myBoolean était null et a évité la NullPointerException. Comprendre comment gérer les valeurs null avec les objets Boolean est crucial pour écrire un code Java robuste.

Utiliser la classe Optional pour gérer les valeurs null

Dans cette étape, nous allons explorer une approche plus moderne pour gérer les valeurs null potentielles en Java en utilisant la classe Optional, introduite en Java 8. Optional est un objet conteneur qui peut ou non contenir une valeur non nulle. Il offre un moyen clair d'indiquer qu'une valeur peut être absente, ce qui permet d'éviter les erreurs NullPointerException et rend le code plus lisible.

Modifions notre exemple précédent pour utiliser Optional<Boolean>.

Ouvrez le fichier BooleanCheck.java dans l'éditeur WebIDE.

Remplacez tout le contenu du fichier par le nouveau code suivant :

import java.util.Optional;

public class BooleanCheck {
    public static void main(String[] args) {
        // Creating an Optional that contains a Boolean value
        Optional<Boolean> optionalBooleanPresent = Optional.of(true);

        // Creating an Optional that is empty (represents null)
        Optional<Boolean> optionalBooleanEmpty = Optional.empty();

        // Handling the present Optional
        if (optionalBooleanPresent.isPresent()) {
            System.out.println("optionalBooleanPresent has a value: " + optionalBooleanPresent.get());
        } else {
            System.out.println("optionalBooleanPresent is empty");
        }

        // Handling the empty Optional
        if (optionalBooleanEmpty.isPresent()) {
            System.out.println("optionalBooleanEmpty has a value: " + optionalBooleanEmpty.get());
        } else {
            System.out.println("optionalBooleanEmpty is empty");
        }

        // Using orElse to provide a default value if the Optional is empty
        Boolean valueOrDefault = optionalBooleanEmpty.orElse(false);
        System.out.println("Value from optionalBooleanEmpty orElse(false): " + valueOrDefault);

        // Using ifPresent to perform an action only if a value is present
        optionalBooleanPresent.ifPresent(value -> System.out.println("Value is present: " + value));
    }
}

Dans ce code mis à jour :

Nous importons la classe java.util.Optional.
Nous créons deux objets Optional<Boolean> : l'un avec une valeur (Optional.of(true)) et l'autre vide (Optional.empty()).
Nous utilisons isPresent() pour vérifier si un Optional contient une valeur.
Nous utilisons get() pour récupérer la valeur d'un Optional. Remarque : Appeler get() sur un Optional vide lèvera une NoSuchElementException, donc vérifiez toujours avec isPresent() d'abord ou utilisez d'autres méthodes Optional.
Nous démontrons orElse(false), qui renvoie la valeur contenue si elle est présente, sinon renvoie la valeur par défaut spécifiée (ici false).
Nous montrons ifPresent(), qui prend une expression lambda et l'exécute uniquement si une valeur est présente dans le Optional.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Ouvrez le terminal en bas de l'éditeur WebIDE. Assurez-vous d'être dans le répertoire ~/project en utilisant la commande cd ~/project.
Compilez le programme Java en tapant la commande suivante et en appuyant sur Entrée :
```
javac BooleanCheck.java
```
Si la compilation réussit, un nouveau fichier BooleanCheck.class sera généré.

Exécutez le programme compilé en utilisant la commande suivante et en appuyant sur Entrée :

java BooleanCheck

Vous devriez voir la sortie suivante :

optionalBooleanPresent has a value: true
optionalBooleanEmpty is empty
Value from optionalBooleanEmpty orElse(false): false
Value is present: true

Cette sortie montre comment Optional peut être utilisé pour gérer la présence ou l'absence d'une valeur de manière plus explicite et plus sûre que simplement en utilisant null. L'utilisation de Optional peut rendre votre code plus clair et réduire la probabilité de NullPointerException.

Tester avec des types primitifs et des types enveloppeurs

Dans cette étape, nous mettrons en évidence la différence clé entre le type primitif boolean de Java et la classe wrapper Boolean, en particulier en ce qui concerne leur capacité à être null. Comprendre cette distinction est essentiel pour éviter les NullPointerException lors de l'utilisation de valeurs booléennes.

Type primitif boolean : C'est un type de données de base en Java. Il ne peut contenir que l'une des deux valeurs suivantes : true ou false. Une variable de type primitif boolean ne peut jamais être null.
Classe wrapper Boolean : C'est un objet qui encapsule une valeur de type primitif boolean. Étant un objet, une variable de type Boolean peut contenir une référence à un objet Boolean (qui contient true ou false) ou la valeur null.

Créons un simple programme pour illustrer cette différence.

Ouvrez l'éditeur WebIDE.
Dans l'explorateur de fichiers à gauche, assurez-vous d'être dans le répertoire ~/project.
Cliquez avec le bouton droit dans l'espace vide de l'explorateur de fichiers, sélectionnez "Nouveau fichier" et nommez-le PrimitiveVsWrapper.java.
Ouvrez le fichier PrimitiveVsWrapper.java dans l'éditeur.

Copiez et collez le code suivant dans l'éditeur :

public class PrimitiveVsWrapper {
    public static void main(String[] args) {
        // Declaring a primitive boolean
        boolean primitiveBoolean = true;

        // Declaring a Boolean wrapper object
        Boolean wrapperBoolean = null; // Wrapper can be null

        System.out.println("Primitive boolean value: " + primitiveBoolean);

        // Checking if the wrapper Boolean is null before printing
        if (wrapperBoolean == null) {
            System.out.println("Wrapper Boolean is null");
        } else {
            System.out.println("Wrapper Boolean value: " + wrapperBoolean);
        }

        // Attempting to assign null to a primitive boolean will cause a compile-time error
        // primitiveBoolean = null; // Uncommenting this line will cause an error
    }
}

Dans ce code :

Nous déclarons un type primitif boolean et l'initialisons à true.
Nous déclarons un objet wrapper Boolean et l'initialisons à null. Cela est valide pour la classe wrapper.
Nous affichons la valeur du type primitif boolean.
Nous vérifions si le wrapper boolean est null avant d'essayer d'afficher sa valeur, ce qui démontre la nécessité de vérifier les valeurs null pour les types wrapper.
La ligne mise en commentaire montre que vous ne pouvez pas assigner null à un type primitif boolean. Si vous supprimez le commentaire de cette ligne et que vous essayez de compiler, vous obtiendrez une erreur de compilation.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Ouvrez le terminal en bas de l'éditeur WebIDE. Assurez-vous d'être dans le répertoire ~/project en utilisant la commande cd ~/project.
Compilez le programme Java en tapant la commande suivante et en appuyant sur Entrée :
```
javac PrimitiveVsWrapper.java
```
S'il n'y a pas d'erreurs, un fichier PrimitiveVsWrapper.class sera créé.
Exécutez le programme compilé en utilisant la commande suivante et en appuyant sur Entrée :
```
java PrimitiveVsWrapper
```
Vous devriez voir la sortie suivante :
```
Primitive boolean value: true
Wrapper Boolean is null
```

Cette sortie montre clairement que le type primitif boolean contient une valeur (true), tandis que l'objet wrapper Boolean peut contenir null. Cette distinction est importante lors de la conception de vos programmes Java et de la gestion des valeurs potentiellement manquantes.

Résumé

Dans ce laboratoire (lab), nous avons appris à gérer les valeurs null potentielles lors de l'utilisation d'objets Boolean en Java. Nous avons vu que contrairement aux types primitifs boolean, la classe wrapper Boolean peut être null, ce qui peut entraîner des erreurs NullPointerException. Nous avons démontré la bonne façon de vérifier si un objet Boolean n'est pas null avant d'accéder à sa valeur booléenne en utilisant la vérification != null combinée avec l'opérateur ET logique (&&). Cela garantit que la valeur booléenne n'est évaluée que si l'objet n'est pas null, évitant ainsi les erreurs à l'exécution.