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

Introduction

Dans ce laboratoire (lab), vous apprendrez à manipuler en toute sécurité les objets wrapper Integer en Java, en particulier en vérifiant s'ils sont null. Contrairement au type primitif int, Integer est un objet qui peut contenir une référence null, et le fait de ne pas vérifier la valeur null peut entraîner des erreurs courantes de type NullPointerException.

À travers des exemples pratiques, vous explorerez la vérification de base == null, combinerez les vérifications de nullité avec des comparaisons de valeurs, et enfin, apprendrez à utiliser la classe Optional pour une gestion plus robuste et expressive des valeurs nulles dans votre code Java.

Tester l'objet wrapper Integer pour la nullité

Dans cette étape, nous allons explorer comment manipuler les objets wrapper Integer en Java, en particulier en vérifiant s'ils sont null. Contrairement aux types primitifs comme int, Integer est une classe, ce qui signifie qu'une variable de type Integer peut contenir une référence à un objet, ou être null si elle ne fait référence à aucun objet. La gestion des valeurs null est cruciale en Java pour éviter les erreurs de type NullPointerException, qui sont très courantes et peuvent faire planter votre programme.

Créons un simple programme Java pour démontrer la vérification de la nullité d'un Integer.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE. Si vous avez terminé le laboratoire précédent, ce fichier devrait déjà exister dans le répertoire ~/project.

Remplacez le code existant dans HelloJava.java par le code suivant :

public class HelloJava {
    public static void main(String[] args) {
        Integer myInteger = null; // Déclaration d'un Integer et initialisation à null

        // Vérification si myInteger est null
        if (myInteger == null) {
            System.out.println("myInteger is null.");
        } else {
            System.out.println("myInteger is not null. Its value is: " + myInteger);
        }

        // Essayons avec un Integer non null
        Integer anotherInteger = 10; // Déclaration et initialisation avec une valeur

        // Vérification si anotherInteger est null
        if (anotherInteger == null) {
            System.out.println("anotherInteger is null.");
        } else {
            System.out.println("anotherInteger is not null. Its value is: " + anotherInteger);
        }
    }
}

Dans ce code :

Nous déclarons une variable Integer nommée myInteger et l'initialisons explicitement à null.
Nous utilisons une instruction if pour vérifier si myInteger est égal à null en utilisant l'opérateur ==. C'est la méthode standard pour vérifier si une référence d'objet est null en Java.
Nous déclarons ensuite une autre variable Integer nommée anotherInteger et lui assignons la valeur 10. Java convertit automatiquement la valeur primitive int 10 en un objet Integer (cela s'appelle l'autoboxing).
Nous effectuons la même vérification de nullité sur anotherInteger.

Enregistrez le fichier HelloJava.java (Ctrl+S ou Cmd+S).
Compilez maintenant le programme en utilisant la commande javac dans le terminal. Assurez-vous d'être dans le répertoire ~/project.
```
javac HelloJava.java
```
S'il n'y a pas d'erreurs, la compilation se terminera silencieusement et un fichier HelloJava.class sera créé dans le répertoire ~/project.
Exécutez le programme compilé en utilisant la commande java :
```
java HelloJava
```
Vous devriez voir une sortie similaire à ceci :
```
myInteger is null.
anotherInteger is not null. Its value is: 10
```
Cette sortie confirme que notre vérification de nullité a fonctionné correctement pour l'Integer null et l'Integer non null. Comprendre comment vérifier la nullité est une compétence fondamentale en programmation Java, en particulier lorsqu'il s'agit de classes wrapper et d'objets qui ne sont pas toujours initialisés avec une valeur.

Combiner les vérifications de nullité et de valeur

Dans l'étape précédente, nous avons appris à vérifier si un objet Integer est null. Souvent, vous devrez vérifier si un Integer n'est pas null ET si sa valeur répond à une certaine condition. Combiner ces vérifications est important car essayer d'accéder à la valeur d'un Integer null entraînera une erreur NullPointerException.

Modifions notre programme pour démontrer la combinaison d'une vérification de nullité avec une vérification de valeur.

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

Remplacez le code existant par le code suivant :

public class HelloJava {
    public static void main(String[] args) {
        Integer score = null; // Exemple 1 : score est null

        // Vérifier si score n'est pas null ET si sa valeur est supérieure à 50
        if (score != null && score > 50) {
            System.out.println("Score is not null and is greater than 50.");
        } else {
            System.out.println("Score is null or not greater than 50.");
        }

        Integer anotherScore = 75; // Exemple 2 : score est 75

        // Vérifier si anotherScore n'est pas null ET si sa valeur est supérieure à 50
        if (anotherScore != null && anotherScore > 50) {
            System.out.println("anotherScore is not null and is greater than 50.");
        } else {
            System.out.println("anotherScore is null or not greater than 50.");
        }

        Integer yetAnotherScore = 40; // Exemple 3 : score est 40

        // Vérifier si yetAnotherScore n'est pas null ET si sa valeur est supérieure à 50
        if (yetAnotherScore != null && yetAnotherScore > 50) {
            System.out.println("yetAnotherScore is not null and is greater than 50.");
        } else {
            System.out.println("yetAnotherScore is null or not greater than 50.");
        }
    }
}

Dans ce code mis à jour :

Nous utilisons l'opérateur logique ET (&&) pour combiner deux conditions : score != null et score > 50.
La vérification score != null est placée en premier. En Java, l'opérateur && utilise une évaluation paresseuse (short - circuit evaluation). Cela signifie que si la première condition (score != null) est fausse, la deuxième condition (score > 50) n'est pas évaluée. Cela empêche une erreur NullPointerException lorsque score est null, car le code score > 50 ne serait pas exécuté.
Nous testons cette logique avec trois variables Integer différentes : une qui est null, une qui n'est pas null et supérieure à 50, et une qui n'est pas null mais pas supérieure à 50.

Enregistrez le fichier HelloJava.java.
Compilez le programme modifié dans le terminal :
```
javac HelloJava.java
```
Exécutez le programme compilé :
```
java HelloJava
```
Vous devriez voir une sortie similaire à ceci :
```
Score is null or not greater than 50.
anotherScore is not null and is greater than 50.
yetAnotherScore is null or not greater than 50.
```
Cette sortie démontre le fonctionnement de la vérification combinée. Le premier cas identifie correctement que score est null. Le deuxième cas identifie que anotherScore n'est pas null et est supérieure à 50. Le troisième cas identifie que yetAnotherScore n'est pas supérieure à 50, même si elle n'est pas null. Ce modèle de vérification de la nullité avant d'accéder aux propriétés ou à la valeur d'un objet est une pratique de sécurité fondamentale en Java.

Utiliser Optional pour une gestion sûre

Bien que la vérification de la nullité avec == null et la combinaison de vérifications avec && soit efficace, Java 8 a introduit la classe Optional comme une manière plus idiomatique de gérer les valeurs qui peuvent être absentes (c'est-à-dire null). Optional est un objet conteneur qui peut ou non contenir une valeur non nulle. L'utilisation de Optional peut rendre votre code plus lisible et moins sujet aux erreurs NullPointerException.

Dans cette étape, nous allons refactoriser notre programme pour utiliser Optional<Integer> afin de gérer les valeurs entières potentiellement absentes.

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

Remplacez le code existant par le code suivant :

import java.util.Optional;

public class HelloJava {
    public static void main(String[] args) {
        // Exemple 1 : Optional contenant une valeur nulle (Optional vide)
        Optional<Integer> optionalScoreNull = Optional.empty();

        // Vérifier si l'Optional contient une valeur et si elle est supérieure à 50
        if (optionalScoreNull.isPresent() && optionalScoreNull.get() > 50) {
             System.out.println("optionalScoreNull is present and greater than 50.");
        } else {
             System.out.println("optionalScoreNull is empty or not greater than 50.");
        }

        // Exemple 2 : Optional contenant une valeur non nulle (75)
        Optional<Integer> optionalScorePresent = Optional.of(75);

        // Vérifier si l'Optional contient une valeur et si elle est supérieure à 50
        if (optionalScorePresent.isPresent() && optionalScorePresent.get() > 50) {
             System.out.println("optionalScorePresent is present and greater than 50.");
        } else {
             System.out.println("optionalScorePresent is empty or not greater than 50.");
        }

        // Exemple 3 : Optional contenant une valeur non nulle (40)
        Optional<Integer> optionalScoreNotGreater = Optional.of(40);

        // Vérifier si l'Optional contient une valeur et si elle est supérieure à 50
        if (optionalScoreNotGreater.isPresent() && optionalScoreNotGreater.get() > 50) {
             System.out.println("optionalScoreNotGreater is present and greater than 50.");
        } else {
             System.out.println("optionalScoreNotGreater is empty or not greater than 50.");
        }

        // Une approche plus fonctionnelle en utilisant les méthodes d'Optional
        System.out.println("\nUsing Optional methods:");

        optionalScoreNull.ifPresent(value -> System.out.println("Value from optionalScoreNull: " + value));
        optionalScorePresent.ifPresent(value -> System.out.println("Value from optionalScorePresent: " + value));
        optionalScoreNotGreater.ifPresent(value -> System.out.println("Value from optionalScoreNotGreater: " + value));

        // Utilisation de orElse pour fournir une valeur par défaut si l'Optional est vide
        Integer scoreOrDefault = optionalScoreNull.orElse(0);
        System.out.println("Value from optionalScoreNull with default: " + scoreOrDefault);

        // Utilisation de filter pour des vérifications conditionnelles
        optionalScorePresent.filter(value -> value > 50)
                            .ifPresent(value -> System.out.println("Filtered optionalScorePresent value: " + value));

         optionalScoreNotGreater.filter(value -> value > 50)
                            .ifPresent(value -> System.out.println("Filtered optionalScoreNotGreater value: " + value));
    }
}

Examinons les principales modifications :

import java.util.Optional; : Nous importons la classe Optional.
Optional<Integer> optionalScoreNull = Optional.empty(); : Nous créons un Optional vide pour représenter l'absence de valeur.
Optional<Integer> optionalScorePresent = Optional.of(75); : Nous créons un Optional contenant une valeur non nulle en utilisant Optional.of(). Notez que Optional.of() lèvera une NullPointerException si vous lui passez une valeur null. Si la valeur peut être null, utilisez Optional.ofNullable().
optionalScoreNull.isPresent() : Cette méthode vérifie si l'Optional contient une valeur. C'est la manière recommandée de vérifier la présence plutôt que de vérifier la nullité.
optionalScoreNull.get() : Cette méthode récupère la valeur de l'Optional. Attention ! Si l'Optional est vide, l'appel de get() lèvera une NoSuchElementException. C'est pourquoi vous devriez toujours vérifier isPresent() avant d'appeler get(), ou utiliser d'autres méthodes d'Optional qui gèrent correctement le cas où l'Optional est vide.
optionalScoreNull.ifPresent(value -> ...) : Cette méthode exécute le code fourni uniquement si l'Optional contient une valeur. C'est une manière propre d'effectuer une action sur la valeur si elle existe.
optionalScoreNull.orElse(0) : Cette méthode renvoie la valeur si elle est présente, sinon elle renvoie la valeur par défaut spécifiée (0 dans ce cas).
optionalScorePresent.filter(value -> value > 50) : Cette méthode renvoie un Optional contenant la valeur si elle est présente ET correspond à la condition donnée (valeur > 50), sinon elle renvoie un Optional vide.

Enregistrez le fichier HelloJava.java.
Compilez le programme dans le terminal :
```
javac HelloJava.java
```
Exécutez le programme compilé :
```
java HelloJava
```
Vous devriez voir une sortie similaire à ceci :
```
optionalScoreNull is empty or not greater than 50.
optionalScorePresent is present and greater than 50.
optionalScoreNotGreater is empty or not greater than 50.

Using Optional methods:
Value from optionalScorePresent: 75
Value from optionalScoreNotGreater: 40
Value from optionalScoreNull with default: 0
Filtered optionalScorePresent value: 75
```
Cette sortie montre comment Optional peut être utilisé pour gérer la présence ou l'absence de valeurs et effectuer des opérations de manière sûre. Bien que le modèle if (isPresent() && get() > 50) soit similaire à la vérification de nullité, Optional offre de nombreuses autres méthodes utiles (ifPresent, orElse, filter, map, etc.) qui peuvent conduire à un code plus expressif et plus sûr lorsqu'il s'agit de valeurs potentiellement absentes. L'utilisation de Optional est une bonne pratique dans le développement Java moderne.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si un objet wrapper Integer est null en Java. Nous avons commencé par comprendre que Integer est une classe et peut contenir une référence null, contrairement au type primitif int. Nous avons démontré la vérification de base == null à l'aide d'un simple programme Java, montrant comment gérer les variables Integer null et non null pour éviter les erreurs NullPointerException.