Comment vérifier si un Set est vide en Java

Introduction

Dans ce laboratoire, vous apprendrez à vérifier si un Set en Java est vide. Nous allons explorer la méthode standard isEmpty(), un moyen simple et efficace de déterminer si un ensemble contient des éléments.

Vous apprendrez également à vérifier la taille d'un ensemble en utilisant la méthode size() et à comprendre comment gérer le potentiel NullPointerException lors de la manipulation d'ensembles nuls. À la fin de ce laboratoire, vous serez compétent pour vérifier l'absence d'éléments dans les ensembles Java dans diverses situations.

Utilisez isEmpty() pour vérifier un Set

Dans cette étape, nous allons apprendre à vérifier si un Set en Java est vide en utilisant la méthode isEmpty(). Un Set est une collection qui ne peut pas contenir d'éléments dupliqués. La méthode isEmpty() est un moyen simple et efficace de déterminer si une collection contient des éléments.

Tout d'abord, créons un nouveau fichier Java nommé SetCheck.java dans votre répertoire ~/project. Vous pouvez le faire en cliquant avec le bouton droit dans l'explorateur de fichiers à gauche et en sélectionnant "Nouveau fichier", puis en tapant SetCheck.java.
Ouvrez le fichier SetCheck.java dans l'éditeur et ajoutez le code suivant :
```
import java.util.HashSet;
import java.util.Set;

public class SetCheck {

    public static void main(String[] args) {
        // Create a new HashSet
        Set<String> fruits = new HashSet<>();

        // Check if the set is empty using isEmpty()
        boolean isEmptyBeforeAdd = fruits.isEmpty();
        System.out.println("Is the fruits set empty before adding elements? " + isEmptyBeforeAdd);

        // Add some elements to the set
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Check if the set is empty after adding elements
        boolean isEmptyAfterAdd = fruits.isEmpty();
        System.out.println("Is the fruits set empty after adding elements? " + isEmptyAfterAdd);
    }
}
```
Décortiquons les nouvelles parties de ce code :
- import java.util.HashSet; et import java.util.Set; : Ces lignes importent les classes nécessaires pour travailler avec Set et HashSet.
- Set<String> fruits = new HashSet<>(); : Cette ligne crée un nouvel objet HashSet nommé fruits. Nous spécifions <String> pour indiquer que cet ensemble stockera des objets String.
- boolean isEmptyBeforeAdd = fruits.isEmpty(); : Cette ligne appelle la méthode isEmpty() sur l'ensemble fruits et stocke le résultat (soit true, soit false) dans une variable booléenne nommée isEmptyBeforeAdd.
- fruits.add("Apple"); : Cette ligne ajoute la chaîne de caractères "Apple" à l'ensemble fruits.
- boolean isEmptyAfterAdd = fruits.isEmpty(); : Cette ligne vérifie si l'ensemble est vide à nouveau après avoir ajouté des éléments.
Enregistrez le fichier SetCheck.java (Ctrl+S ou Cmd+S).
Maintenant, compilons le programme Java. Ouvrez le terminal en bas de l'IDE Web et assurez-vous que vous êtes dans le répertoire ~/project. Ensuite, exécutez la commande suivante :
```
javac SetCheck.java
```
Si la compilation réussit, vous ne verrez aucun message de sortie.
Enfin, exécutez le programme compilé en utilisant la commande java :
```
java SetCheck
```
Vous devriez voir une sortie similaire à ceci :
```
Is the fruits set empty before adding elements? true
Is the fruits set empty after adding elements? false
```
Cette sortie confirme que la méthode isEmpty() a correctement indiqué l'état de l'ensemble avant et après avoir ajouté des éléments.

Vérifiez la taille d'un Set avec size()

Dans l'étape précédente, nous avons appris à vérifier si un Set est vide en utilisant isEmpty(). Une autre opération courante consiste à déterminer combien d'éléments se trouvent dans un Set. Pour cela, nous utilisons la méthode size(). La méthode size() renvoie le nombre d'éléments actuellement présents dans l'ensemble.

Ouvrez le fichier SetCheck.java dans votre répertoire ~/project dans l'éditeur de l'IDE Web.

Modifiez la méthode main pour inclure des appels à la méthode size(). Remplacez la méthode main existante par le code suivant :

import java.util.HashSet;
import java.util.Set;

public class SetCheck {

    public static void main(String[] args) {
        // Create a new HashSet
        Set<String> fruits = new HashSet<>();

        // Check the size of the set before adding elements
        int sizeBeforeAdd = fruits.size();
        System.out.println("Size of the fruits set before adding elements: " + sizeBeforeAdd);

        // Add some elements to the set
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Check the size of the set after adding elements
        int sizeAfterAdd = fruits.size();
        System.out.println("Size of the fruits set after adding elements: " + sizeAfterAdd);

        // Add a duplicate element (Sets do not allow duplicates)
        fruits.add("Apple");

        // Check the size again
        int sizeAfterDuplicateAdd = fruits.size();
        System.out.println("Size of the fruits set after adding a duplicate: " + sizeAfterDuplicateAdd);
    }
}

Voici ce que nous avons ajouté :

int sizeBeforeAdd = fruits.size(); : Cette ligne appelle la méthode size() sur l'ensemble fruits et stocke la valeur entière renvoyée (le nombre d'éléments) dans une variable nommée sizeBeforeAdd.
int sizeAfterAdd = fruits.size(); : Cela vérifie la taille après avoir ajouté les trois premiers éléments.
fruits.add("Apple"); : Nous essayons d'ajouter "Apple" à nouveau. Comme "Apple" est déjà dans l'ensemble, cette opération ne changera pas le contenu de l'ensemble.
int sizeAfterDuplicateAdd = fruits.size(); : Cela vérifie la taille après avoir essayé d'ajouter un élément en double.

Enregistrez le fichier SetCheck.java.
Compilez le programme Java modifié dans le terminal :
```
javac SetCheck.java
```
Encore une fois, l'absence de sortie indique que la compilation a réussi.
Exécutez le programme :
```
java SetCheck
```
Vous devriez voir une sortie similaire à ceci :
```
Size of the fruits set before adding elements: 0
Size of the fruits set after adding elements: 3
Size of the fruits set after adding a duplicate: 3
```
Cette sortie montre que la méthode size() indique correctement le nombre d'éléments et que l'ajout d'un élément en double n'augmente pas la taille de l'ensemble.

Gérer les Sets null

Dans les étapes précédentes, nous avons travaillé avec un Set correctement initialisé. Cependant, dans la programmation réelle, vous pourriez rencontrer des situations où une variable de type Set est null. Tenter d'appeler des méthodes telles que isEmpty() ou size() sur un objet null entraînera une NullPointerException, qui est une erreur courante en Java. Il est important de gérer ces cas de manière élégante.

Ouvrez le fichier SetCheck.java dans votre répertoire ~/project dans l'éditeur de l'IDE Web.

Modifiez la méthode main pour démontrer comment gérer un Set null. Remplacez la méthode main existante par le code suivant :

import java.util.HashSet;
import java.util.Set;

public class SetCheck {

    public static void main(String[] args) {
        // Declare a Set variable but initialize it to null
        Set<String> colors = null;

        // Attempting to call isEmpty() or size() here would cause a NullPointerException
        // System.out.println("Is the colors set empty? " + colors.isEmpty()); // This would crash!

        // To safely check if a set is null or empty, we first check for null
        if (colors == null) {
            System.out.println("The colors set is null.");
        } else {
            // If it's not null, we can safely check if it's empty
            if (colors.isEmpty()) {
                System.out.println("The colors set is empty.");
            } else {
                System.out.println("The colors set is not empty and has " + colors.size() + " elements.");
            }
        }

        // Now, let's initialize the set and add elements
        colors = new HashSet<>();
        colors.add("Red");
        colors.add("Blue");

        // Check again after initialization and adding elements
        if (colors == null) {
            System.out.println("The colors set is null.");
        } else {
            if (colors.isEmpty()) {
                System.out.println("The colors set is empty.");
            } else {
                System.out.println("The colors set is not empty and has " + colors.size() + " elements.");
            }
        }
    }
}

Dans ce code mis à jour :

Set<String> colors = null; : Nous déclarons une variable Set nommée colors mais nous l'initialisons explicitement à null.
Nous avons commenté la ligne qui aurait causé une NullPointerException.
if (colors == null) : C'est la vérification cruciale. Avant d'appeler toute méthode sur la variable colors, nous vérifions d'abord si elle est null.
Si colors n'est pas null, nous procédons ensuite à vérifier si elle est vide en utilisant colors.isEmpty() ou à obtenir sa taille en utilisant colors.size().
Nous initialisons ensuite colors avec un nouveau HashSet et ajoutons des éléments pour montrer la sortie différente lorsque l'ensemble n'est ni null ni vide.

Enregistrez le fichier SetCheck.java.
Compilez le programme dans le terminal :
```
javac SetCheck.java
```
Exécutez le programme :
```
java SetCheck
```
Vous devriez voir une sortie similaire à ceci :
```
The colors set is null.
The colors set is not empty and has 2 elements.
```
Cela démontre comment gérer en toute sécurité les valeurs null potentielles pour une variable de type Set avant de tenter d'accéder à ses méthodes. Vérifiez toujours si une référence d'objet est null avant de la manipuler, surtout si elle peut ne pas être initialisée.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si un Set en Java est vide. Nous avons commencé par utiliser la méthode isEmpty(), qui est le moyen standard et le plus efficace pour effectuer cette vérification. Nous avons créé un HashSet, vérifié son état de vacuité avant et après avoir ajouté des éléments, et observé la sortie booléenne de isEmpty(). Cela a démontré l'utilisation de base de isEmpty() pour déterminer si un ensemble contient des éléments.