Comment vérifier si un objet Boolean est null en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier en toute sécurité si un objet wrapper Boolean est null en Java. Contrairement au type primitif boolean, la classe Boolean peut contenir une valeur null, ce qui peut entraîner une NullPointerException si elle n'est pas gérée correctement.

Nous explorerons différentes techniques pour gérer les objets Boolean null, y compris les vérifications directes de nullité, la combinaison de vérifications de nullité et de valeurs vraies/fausses, et l'utilisation de la classe Optional pour une gestion plus robuste des valeurs nulles. À la fin de ce laboratoire, vous serez en mesure d'éviter les pièges courants lors de la manipulation d'objets wrapper Boolean en Java.

Tester si un wrapper Boolean est null

Dans cette étape, nous allons explorer comment gérer les objets wrapper Boolean en Java, en particulier en vérifiant si un objet Boolean est null. Contrairement au type primitif boolean qui ne peut être que true ou false, la classe wrapper Boolean peut également contenir une valeur null. Cela est une source courante de NullPointerException si cela n'est pas géré avec soin.

Créons un simple programme Java pour illustrer cela.

Ouvrez le répertoire ~/project dans l'explorateur de fichiers situé à gauche de l'éditeur WebIDE.
Cliquez avec le bouton droit dans l'espace vide du répertoire ~/project et sélectionnez "Nouveau fichier".
Nommez le nouveau fichier BooleanCheck.java et appuyez sur Entrée.
Ouvrez le fichier BooleanCheck.java dans l'éditeur de code.

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

public class BooleanCheck {

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

        // Tentative d'utilisation directe d'un objet Boolean null dans une condition
        // entraînera une NullPointerException
        // if (myBoolean) {
        //     System.out.println("Ceci ne sera pas affiché si myBoolean est null.");
        // }

        // Méthode correcte pour vérifier si un objet wrapper Boolean est null
        if (myBoolean == null) {
            System.out.println("myBoolean est null.");
        } else {
            System.out.println("myBoolean n'est pas null.");
        }

        // Une autre façon de vérifier la valeur booléenne en toute sécurité
        if (Boolean.TRUE.equals(myBoolean)) {
             System.out.println("myBoolean est true.");
        } else if (Boolean.FALSE.equals(myBoolean)) {
             System.out.println("myBoolean est false.");
        } else {
             System.out.println("myBoolean est null (vérifié avec equals).");
        }
    }
}

Enregistrez le fichier en appuyant sur Ctrl + S (ou Cmd + S sur Mac).
Maintenant, compilons le programme Java. Ouvrez le terminal en bas de l'éditeur WebIDE. Assurez-vous que vous êtes dans le répertoire ~/project. Sinon, tapez cd ~/project et appuyez sur Entrée.
Compilez le code en utilisant la commande javac :
```
javac BooleanCheck.java
```
S'il n'y a pas d'erreurs, la commande s'exécutera sans afficher de sortie. Cela signifie qu'un fichier BooleanCheck.class a été créé dans le répertoire ~/project.
Exécutez le programme Java compilé en utilisant la commande java :
```
java BooleanCheck
```

Vous devriez voir la sortie suivante dans le terminal :

myBoolean est null.
myBoolean est null (vérifié avec equals).

Cette sortie confirme que notre code a correctement identifié l'objet Boolean comme null en utilisant la vérification == null et le modèle Boolean.TRUE.equals() / Boolean.FALSE.equals(). Le code mis en commentaire montre ce qui se passerait si vous essayiez d'utiliser un objet Boolean null directement dans une condition if, ce qui entraînerait une NullPointerException.

Comprendre comment gérer en toute sécurité les objets Boolean null est crucial pour éviter les erreurs courantes en programmation Java.

Combiner les vérifications de nullité et de valeurs true/false

Dans l'étape précédente, nous avons vu comment vérifier si un objet Boolean est null. Souvent, vous devez vérifier si un Boolean est true, false ou null. Combiner efficacement et en toute sécurité ces vérifications est important.

Modifions notre programme BooleanCheck.java pour montrer comment gérer ces trois possibilités.

Ouvrez le fichier BooleanCheck.java dans l'éditeur de code s'il n'est pas déjà ouvert. Il devrait se trouver dans le répertoire ~/project.

Remplacez le code existant dans BooleanCheck.java par le code suivant. Cette version inclut des exemples pour les valeurs Boolean null, true et false.

public class BooleanCheck {

    public static void main(String[] args) {
        Boolean booleanValue1 = null;
        Boolean booleanValue2 = true;
        Boolean booleanValue3 = false;

        System.out.println("Checking booleanValue1 (null):");
        checkBoolean(booleanValue1);

        System.out.println("\nChecking booleanValue2 (true):");
        checkBoolean(booleanValue2);

        System.out.println("\nChecking booleanValue3 (false):");
        checkBoolean(booleanValue3);
    }

    // Une méthode auxiliaire pour démontrer les vérifications
    public static void checkBoolean(Boolean value) {
        if (value == null) {
            System.out.println("Value is null.");
        } else if (value) { // Ceci est sûr car nous avons déjà vérifié la nullité
            System.out.println("Value is true.");
        } else { // Si non null et non true, cela doit être false
            System.out.println("Value is false.");
        }

        // Un autre modèle courant utilisant equals pour plus de sécurité
        System.out.print("Using equals: ");
        if (Boolean.TRUE.equals(value)) {
             System.out.println("Value is true.");
        } else if (Boolean.FALSE.equals(value)) {
             System.out.println("Value is false.");
        } else {
             System.out.println("Value is null.");
        }
    }
}

Dans ce code mis à jour :

Nous définissons une méthode auxiliaire checkBoolean qui prend un objet Boolean en entrée.
À l'intérieur de checkBoolean, nous vérifions d'abord si la value est null en utilisant value == null.
Si elle n'est pas null, nous vérifions ensuite en toute sécurité si la valeur booléenne est true en utilisant value. Cela fonctionne car Java déballera automatiquement l'objet wrapper Boolean en un type primitif boolean seulement si le wrapper n'est pas null.
Si elle n'est pas null et pas true, elle doit être false, ce qui est géré dans le bloc else.
Nous incluons également le modèle Boolean.TRUE.equals(value) et Boolean.FALSE.equals(value) à nouveau, qui est une autre façon sûre de vérifier la valeur, particulièrement utile lorsque vous souhaitez éviter une éventuelle NullPointerException si l'objet sur lequel equals est appelé est null.

Enregistrez le fichier (Ctrl + S ou Cmd + S).
Compilez le programme modifié dans le terminal :
```
javac BooleanCheck.java
```
Exécutez le programme compilé :
```
java BooleanCheck
```

Vous devriez voir la sortie suivante, montrant comment le code gère chaque cas :

Checking booleanValue1 (null):
Value is null.
Using equals: Value is null.

Checking booleanValue2 (true):
Value is true.
Using equals: Value is true.

Checking booleanValue3 (false):
Value is false.
Using equals: Value is false.

Cette étape vous montre des méthodes robustes pour vérifier l'état d'un objet wrapper Boolean, en tenant compte des valeurs null, true et false, ce qui est une compétence fondamentale pour écrire un code Java sûr et fiable.

Gérer avec la classe Optional

En Java moderne (Java 8 et versions ultérieures), la classe Optional est souvent utilisée pour représenter une valeur qui peut être présente ou non. Cela peut aider à réduire le nombre de NullPointerException dans votre code en rendant explicite le fait qu'une valeur peut manquer. Bien que Optional<Boolean> ne soit pas toujours le cas d'utilisation le plus courant, c'est un bon moyen de comprendre comment Optional peut être appliqué à des types wrapper comme Boolean.

Dans cette étape, nous allons modifier notre programme pour utiliser Optional<Boolean> afin de gérer la possibilité d'une valeur booléenne manquante.

Ouvrez le fichier BooleanCheck.java dans l'éditeur de code. Il devrait se trouver dans le répertoire ~/project.

Remplacez le code existant par le code suivant qui utilise Optional<Boolean> :

import java.util.Optional;

public class BooleanCheck {

    public static void main(String[] args) {
        Optional<Boolean> optionalBoolean1 = Optional.empty(); // Représente l'absence de valeur
        Optional<Boolean> optionalBoolean2 = Optional.of(true); // Représente la valeur true
        Optional<Boolean> optionalBoolean3 = Optional.of(false); // Représente la valeur false

        System.out.println("Checking optionalBoolean1 (empty):");
        checkOptionalBoolean(optionalBoolean1);

        System.out.println("\nChecking optionalBoolean2 (true):");
        checkOptionalBoolean(optionalBoolean2);

        System.out.println("\nChecking optionalBoolean3 (false):");
        checkOptionalBoolean(optionalBoolean3);
    }

    // Une méthode auxiliaire pour démontrer la vérification d'un Optional<Boolean>
    public static void checkOptionalBoolean(Optional<Boolean> optionalValue) {
        if (optionalValue.isPresent()) {
            // Récupère la valeur booléenne si elle est présente
            Boolean value = optionalValue.get();
            if (value) {
                System.out.println("Value is present and true.");
            } else {
                System.out.println("Value is present and false.");
            }
        } else {
            System.out.println("Value is not present (empty Optional).");
        }

        // Une autre façon en utilisant orElse
        System.out.print("Using orElse(false): ");
        boolean result = optionalValue.orElse(false);
        System.out.println("Result: " + result);

        // Utilisation de ifPresent
        System.out.print("Using ifPresent: ");
        optionalValue.ifPresent(val -> System.out.println("Value is present: " + val));
        if (!optionalValue.isPresent()) {
             System.out.println("Value is not present.");
        }
    }
}

Dans cette version :

Nous importons la classe java.util.Optional.
Nous créons des objets Optional<Boolean> en utilisant Optional.empty() pour une valeur manquante et Optional.of() pour une valeur présente.
La méthode checkOptionalBoolean prend maintenant un Optional<Boolean>.
Nous utilisons optionalValue.isPresent() pour vérifier si une valeur est présente.
Si une valeur est présente, nous la récupérons en utilisant optionalValue.get(). Remarque : Appelez get() seulement après avoir vérifié isPresent(), sinon vous obtiendrez une NoSuchElementException.
Nous démontrons également orElse(false), qui fournit une valeur par défaut (false dans ce cas) si l'Optional est vide.
ifPresent() vous permet d'exécuter une action seulement si une valeur est présente.

Enregistrez le fichier (Ctrl + S ou Cmd + S).
Compilez le programme modifié dans le terminal :
```
javac BooleanCheck.java
```
Exécutez le programme compilé :
```
java BooleanCheck
```

Vous devriez voir la sortie suivante :

Checking optionalBoolean1 (empty):
Value is not present (empty Optional).
Using orElse(false): Result: false
Using ifPresent: Value is not present.

Checking optionalBoolean2 (true):
Value is present and true.
Using orElse(false): Result: true
Using ifPresent: Value is present: true

Checking optionalBoolean3 (false):
Value is present and false.
Using orElse(false): Result: false
Using ifPresent: Value is present: false

Cette sortie montre comment Optional<Boolean> peut être utilisé pour gérer explicitement la présence ou l'absence d'une valeur booléenne, offrant une façon plus robuste de gérer les données potentiellement manquantes par rapport à l'utilisation d'un Boolean nullable.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si un objet wrapper Boolean est null en Java. Nous avons exploré la différence entre le type primitif boolean et la classe wrapper Boolean, en soulignant le risque de NullPointerException lors de la manipulation d'objets Boolean null. Nous avons démontré la bonne façon de vérifier la nullité en utilisant l'opérateur d'égalité (== null) et avons également montré comment vérifier en toute sécurité la valeur booléenne en utilisant la méthode equals() de Boolean.TRUE et Boolean.FALSE. Ces techniques sont essentielles pour éviter les erreurs d'exécution lors de la manipulation d'objets Boolean pouvant être null.