Comment vérifier si un tableau est null en Java

Introduction

Dans ce laboratoire, vous apprendrez à vérifier si un tableau en Java est nul. Nous commencerons par comprendre comment vérifier si la référence du tableau elle-même est nulle pour éviter les NullPointerException.

Ensuite, nous explorerons comment combiner les vérifications de nullité avec les vérifications de longueur pour une gestion plus robuste des tableaux. Enfin, vous testerez votre compréhension en travaillant avec un tableau vide initialisé.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java(("Java")) -.-> java/DataStructuresGroup(["Data Structures"]) java/BasicSyntaxGroup -.-> java/if_else("If...Else") java/DataStructuresGroup -.-> java/arrays("Arrays") subgraph Lab Skills java/if_else -.-> lab-560003{{"Comment vérifier si un tableau est null en Java"}} java/arrays -.-> lab-560003{{"Comment vérifier si un tableau est null en Java"}} end

Vérifier si la référence d'un tableau est nulle

Dans cette étape, nous apprendrons à vérifier si une référence de tableau en Java est null. Vérifier la nullité est une pratique fondamentale en programmation Java pour éviter les NullPointerException, qui sont des erreurs courantes à l'exécution.

Une NullPointerException se produit lorsque vous essayez d'utiliser une variable qui ne fait référence à rien (elle est null) comme si c'était un objet. Imaginez que vous essayiez d'ouvrir une boîte qui n'existe pas – c'est similaire à ce qui se passe lorsque vous obtenez une NullPointerException.

Créons un simple programme Java pour démontrer comment vérifier si une référence de tableau est null.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE s'il n'est pas déjà ouvert.
Remplacez tout le contenu du fichier par le code suivant :
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = null; // Déclaration d'une référence de tableau et initialisation à null

        // Vérifier si la référence de tableau est null avant de l'utiliser
        if (names == null) {
            System.out.println("Le tableau 'names' est null.");
        } else {
            System.out.println("Le tableau 'names' n'est pas null.");
        }
    }
}
```
Examinons les nouvelles parties de ce code :
- String[] names = null; : Cette ligne déclare une variable de tableau nommée names qui peut contenir des objets String. Nous assignons immédiatement la valeur null à cette variable. Cela signifie que la variable names ne fait actuellement référence à aucun objet tableau réel en mémoire.
- if (names == null) : Il s'agit d'une instruction if, qui est utilisée pour prendre des décisions en programmation. Elle vérifie si la condition entre parenthèses (names == null) est vraie. L'opérateur == est utilisé pour comparer si la variable names est égale à null.
- System.out.println("Le tableau 'names' est null."); : Cette ligne sera exécutée uniquement si la condition names == null est vraie.
- System.out.println("Le tableau 'names' n'est pas null."); : Cette ligne sera exécutée uniquement si la condition names == null est fausse (ce qui signifie que names n'est pas null).
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié. Dans le terminal, exécutez :
```
javac HelloJava.java
```
Si la compilation réussit, vous ne verrez aucun message de sortie.
Exécutez le programme compilé :
```
java HelloJava
```
Vous devriez voir la sortie suivante :
```
Le tableau 'names' est null.
```
Cette sortie confirme que notre vérification a correctement identifié la référence du tableau names comme étant null.

Comprendre comment vérifier la nullité est essentiel pour écrire un code Java robuste. Dans l'étape suivante, nous explorerons ce qui se passe lorsque nous essayons d'accéder à la longueur d'un tableau qui est null et comment combiner les vérifications.

Combiner les vérifications de nullité et de longueur

Dans l'étape précédente, nous avons appris à vérifier si une référence de tableau est null. Maintenant, explorons ce qui se passe lorsque nous essayons d'accéder à la longueur d'un tableau null et comment combiner la vérification de nullité avec une vérification de la longueur du tableau.

Tenter d'accéder à la propriété .length d'une référence de tableau null entraînera une NullPointerException. Cela est dû au fait que vous essayez d'accéder à une propriété de quelque chose qui n'existe pas.

Modifions notre programme pour démontrer ce comportement, puis ajoutons une vérification combinée.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.
Remplacez tout le contenu du fichier par le code suivant :
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = null; // Déclaration d'une référence de tableau et initialisation à null

        // Tentative d'accès à la longueur d'un tableau null (causera une erreur)
        // int length = names.length; // Décommenter cette ligne causerait une NullPointerException

        // Combinaison de la vérification de nullité et de la vérification de longueur
        if (names != null && names.length > 0) {
            System.out.println("Le tableau 'names' n'est pas null et contient des éléments.");
        } else {
            System.out.println("Le tableau 'names' est null ou vide.");
        }
    }
}
```
Voici ce qui est nouveau ou a été modifié :
- Nous avons conservé String[] names = null; pour commencer avec un tableau null.
- La ligne commentée // int length = names.length; montre ce qui se passerait si nous essayions d'accéder directement à la longueur. Nous l'avons commentée pour que le programme ne plante pas immédiatement.
- if (names != null && names.length > 0) : Il s'agit de la vérification combinée.
  - names != null : Cette partie vérifie si la référence du tableau names n'est pas null.
  - && : Il s'agit de l'opérateur logique ET. Les deux conditions de chaque côté de && doivent être vraies pour que l'ensemble de la condition soit vraie.
  - names.length > 0 : Cette partie vérifie si la longueur du tableau names est supérieure à 0. Cette vérification n'est effectuée que si la première partie (names != null) est vraie, grâce à la nature de court-circuit de l'opérateur && en Java. Cela évite la NullPointerException.
- Le bloc else affiche maintenant un message indiquant que le tableau est soit null soit vide.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié :
```
javac HelloJava.java
```
Encore une fois, si la compilation réussit, il n'y aura pas de sortie.
Exécutez le programme compilé :
```
java HelloJava
```
Vous devriez voir la sortie suivante :
```
Le tableau 'names' est null ou vide.
```
Cette sortie montre que notre vérification combinée a correctement identifié que le tableau était soit null soit vide. Étant donné que nous l'avons initialisé à null, la première partie de la condition if (names != null) était fausse, et le bloc else a été exécuté.

Combiner des vérifications de cette manière est une méthode standard pour gérer en toute sécurité les références de tableaux en Java, en vous assurant de ne pas rencontrer de NullPointerException lors de la vérification de propriétés telles que la longueur ou de l'accès aux éléments.

Tester avec un tableau vide initialisé

Dans les étapes précédentes, nous avons appris à vérifier les références de tableaux null et à combiner cette vérification avec une vérification de longueur. Nous avons vu que notre vérification combinée identifiait correctement un tableau null.

Maintenant, testons notre vérification combinée avec un tableau qui n'est pas null mais est vide (a une longueur de 0). C'est un autre scénario courant que vous rencontrerez.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.
Modifiez la ligne où nous déclarons et initialisons le tableau names. Remplacez String[] names = null; par String[] names = new String[0];. Le reste du code, y compris l'instruction if avec la vérification combinée, doit rester le même.

Le code mis à jour devrait ressembler à ceci :
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = new String[0]; // Déclaration et initialisation d'un tableau vide

        // Combinaison de la vérification de nullité et de la vérification de longueur
        if (names != null && names.length > 0) {
            System.out.println("Le tableau 'names' n'est pas null et contient des éléments.");
        } else {
            System.out.println("Le tableau 'names' est null ou vide.");
        }
    }
}
```
Voici le changement :
- String[] names = new String[0]; : Cette ligne crée maintenant un nouveau tableau d'objets String de taille 0. La variable names fait maintenant référence à un objet tableau réel en mémoire, mais ce tableau ne contient aucun élément. Il n'est pas null.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié :
```
javac HelloJava.java
```
Si la compilation réussit, il n'y aura pas de sortie.
Exécutez le programme compilé :
```
java HelloJava
```
Vous devriez voir la sortie suivante :
```
Le tableau 'names' est null ou vide.
```
Cette sortie est la même que lorsque le tableau était null. Comprenons pourquoi. Notre condition if est if (names != null && names.length > 0).
- names != null : Cette partie est maintenant vraie car names fait référence à un objet tableau vide.
- names.length > 0 : Cette partie vérifie si la longueur du tableau est supérieure à 0. Étant donné que le tableau a une longueur de 0, cette condition est fausse.
- Étant donné que la deuxième partie de la condition && est fausse, l'ensemble de la condition (names != null && names.length > 0) est évalué à faux, et le bloc else est exécuté.

Cela démontre que notre vérification combinée identifie correctement à la fois les tableaux null et les tableaux vides, ce qui est souvent le comportement souhaité lorsque vous souhaitez traiter un tableau seulement s'il contient des éléments.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si une référence de tableau en Java est null pour éviter les NullPointerException. Nous avons commencé par créer un programme simple pour démontrer la vérification d'une référence de tableau null en utilisant une instruction if et l'opérateur ==.

Nous avons ensuite exploré la combinaison de la vérification de null avec une vérification de longueur pour gérer les cas où le tableau n'est pas null mais pourrait être vide. Enfin, nous avons testé notre vérification combinée avec un tableau vide initialisé pour comprendre la différence entre une référence de tableau null et un tableau vide.