Comment vérifier si une Map est vide en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une Map en Java est vide. Nous explorerons différentes méthodes pour cette opération courante, en commençant par la méthode simple isEmpty(). Vous apprendrez également à vérifier la taille d'une carte (map) en utilisant la méthode size() et, surtout, à gérer les cas où la carte elle-même pourrait être nulle (null) pour éviter les erreurs potentielles de NullPointerException. À la fin de ce laboratoire, vous serez compétent pour déterminer l'absence de contenu des cartes Java dans diverses situations.

Utilisez isEmpty() pour vérifier une Map

Dans cette étape, nous apprendrons à vérifier si une Map en Java est vide en utilisant la méthode isEmpty(). Une Map est une collection de paires clé-valeur, et vérifier si elle est vide est une opération courante.

Tout d'abord, créons un nouveau fichier Java nommé MapCheck.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 MapCheck.java.

Maintenant, ouvrez le fichier MapCheck.java dans l'éditeur et ajoutez le code suivant :

import java.util.HashMap;
import java.util.Map;

public class MapCheck {

    public static void main(String[] args) {
        // Create an empty Map
        Map<String, Integer> emptyMap = new HashMap<>();

        // Check if the map is empty using isEmpty()
        boolean isEmpty = emptyMap.isEmpty();

        // Print the result
        System.out.println("Is the map empty? " + isEmpty);

        // Create a non-empty Map
        Map<String, Integer> nonEmptyMap = new HashMap<>();
        nonEmptyMap.put("one", 1);
        nonEmptyMap.put("two", 2);

        // Check if the non-empty map is empty
        boolean isNonEmpty = nonEmptyMap.isEmpty();

        // Print the result
        System.out.println("Is the non-empty map empty? " + isNonEmpty);
    }
}

Décortiquons le code :

import java.util.HashMap; et import java.util.Map; : Ces lignes importent les classes nécessaires pour travailler avec les Maps.
Map<String, Integer> emptyMap = new HashMap<>(); : Cela crée une nouvelle HashMap vide. HashMap est une implémentation courante de l'interface Map. Nous spécifions que les clés seront des String et les valeurs des Integer.
boolean isEmpty = emptyMap.isEmpty(); : C'est ici que nous utilisons la méthode isEmpty(). Elle retourne true si la carte ne contient aucune paire clé-valeur, et false sinon. Le résultat est stocké dans une variable booléenne isEmpty.
System.out.println("Is the map empty? " + isEmpty); : Cela affiche le résultat de la vérification dans la console.
Le code répète ensuite le processus avec une nonEmptyMap pour montrer comment isEmpty() fonctionne lorsque la carte n'est pas vide.

Enregistrez le fichier MapCheck.java (Ctrl+S ou Cmd+S).

Maintenant, ouvrez le terminal en bas de l'IDE Web. Assurez-vous d'être dans le répertoire ~/project.

Compilez le code Java en utilisant la commande javac :

javac MapCheck.java

S'il n'y a pas d'erreurs, un fichier MapCheck.class sera créé dans le répertoire ~/project.

Enfin, exécutez le programme Java compilé en utilisant la commande java :

java MapCheck

Vous devriez voir la sortie suivante :

Is the map empty? true
Is the non-empty map empty? false

Cette sortie confirme que isEmpty() a correctement identifié la carte vide et la carte non vide. L'utilisation de isEmpty() est la méthode recommandée pour vérifier si une carte est vide, car elle est claire et efficace.

Vérifiez la taille d'une Map avec size()

Dans cette étape, nous apprendrons à obtenir le nombre de paires clé-valeur dans une Map en utilisant la méthode size(). Cela est utile lorsque vous avez besoin de savoir combien d'éléments sont actuellement stockés dans la carte.

Nous continuerons à travailler avec le fichier MapCheck.java que nous avons créé à l'étape précédente. Ouvrez MapCheck.java dans l'éditeur de l'IDE Web.

Maintenant, modifions la méthode main pour inclure la vérification de la taille des cartes. Remplacez le code existant dans la méthode main par le suivant :

import java.util.HashMap;
import java.util.Map;

public class MapCheck {

    public static void main(String[] args) {
        // Create an empty Map
        Map<String, Integer> emptyMap = new HashMap<>();

        // Check the size of the empty map using size()
        int emptySize = emptyMap.size();

        // Print the result
        System.out.println("Size of the empty map: " + emptySize);

        // Create a non-empty Map
        Map<String, Integer> nonEmptyMap = new HashMap<>();
        nonEmptyMap.put("one", 1);
        nonEmptyMap.put("two", 2);
        nonEmptyMap.put("three", 3); // Add one more element

        // Check the size of the non-empty map
        int nonEmptySize = nonEmptyMap.size();

        // Print the result
        System.out.println("Size of the non-empty map: " + nonEmptySize);
    }
}

Examinons les modifications :

int emptySize = emptyMap.size(); : Cette ligne appelle la méthode size() sur la emptyMap. La méthode size() retourne le nombre de paires clé-valeur dans la carte sous forme d'entier. Le résultat est stocké dans une variable entière emptySize.
System.out.println("Size of the empty map: " + emptySize); : Cela affiche la taille de la carte vide.
Nous avons également ajouté un élément supplémentaire ("three", 3) à la nonEmptyMap pour montrer comment la taille change.
int nonEmptySize = nonEmptyMap.size(); : Cela appelle size() sur la nonEmptyMap pour obtenir sa taille.
System.out.println("Size of the non-empty map: " + nonEmptySize); : Cela affiche la taille de la carte non vide.

Enregistrez le fichier MapCheck.java (Ctrl+S ou Cmd+S).

Maintenant, ouvrez le terminal et assurez-vous d'être dans le répertoire ~/project.

Compilez le code Java modifié :

javac MapCheck.java

Si la compilation réussit, exécutez le programme :

java MapCheck

Vous devriez voir la sortie suivante :

Size of the empty map: 0
Size of the non-empty map: 3

Cette sortie montre que size() a correctement indiqué le nombre d'éléments dans les cartes vides et non vides. La méthode size() est un moyen simple et efficace de déterminer le nombre actuel d'entrées dans une Map Java.

Gérer les Maps nulles

Dans les étapes précédentes, nous avons travaillé avec des cartes qui étaient soit vides, soit contenaient des éléments. Cependant, il est important de considérer ce qui se passe si une variable de type Map est null. Une référence null signifie que la variable ne pointe vers aucun objet en mémoire. Tenter d'appeler une méthode comme isEmpty() ou size() sur une carte null entraînera une NullPointerException, qui est une erreur courante en Java.

Dans cette étape, nous apprendrons à gérer en toute sécurité les références potentielles de cartes null avant d'essayer de vérifier leur vacuité ou leur taille.

Ouvrez à nouveau le fichier MapCheck.java dans l'éditeur de l'IDE Web.

Ajoutons du code pour démontrer et gérer une carte null. Modifiez la méthode main pour inclure ce qui suit :

import java.util.HashMap;
import java.util.Map;

public class MapCheck {

    public static void main(String[] args) {
        // Create an empty Map
        Map<String, Integer> emptyMap = new HashMap<>();

        // Check the size of the empty map using size()
        int emptySize = emptyMap.size();

        // Print the result
        System.out.println("Size of the empty map: " + emptySize);

        // Create a non-empty Map
        Map<String, Integer> nonEmptyMap = new HashMap<>();
        nonEmptyMap.put("one", 1);
        nonEmptyMap.put("two", 2);
        nonEmptyMap.put("three", 3); // Add one more element

        // Check the size of the non-empty map
        int nonEmptySize = nonEmptyMap.size();

        // Print the result
        System.out.println("Size of the non-empty map: " + nonEmptySize);

        // Declare a Map variable but don't initialize it (it will be null)
        Map<String, Integer> nullMap = null;

        // --- Handling the null map ---

        // Check if the map is null before calling methods
        if (nullMap == null) {
            System.out.println("The nullMap is null.");
        } else {
            // This block will not be executed for nullMap
            System.out.println("Is the nullMap empty? " + nullMap.isEmpty());
            System.out.println("Size of the nullMap: " + nullMap.size());
        }

        // A safer way to check if a map is empty (handles null)
        boolean isNullMapEmpty = (nullMap == null || nullMap.isEmpty());
        System.out.println("Is the nullMap considered empty (including null)? " + isNullMapEmpty);

        // A safer way to get the size (handles null)
        int nullMapSize = (nullMap == null) ? 0 : nullMap.size();
        System.out.println("Size of the nullMap (handling null): " + nullMapSize);
    }
}

Voici ce que nous avons ajouté :

Map<String, Integer> nullMap = null; : Cela déclare une variable de type Map mais l'initialise explicitement à null.
if (nullMap == null) { ... } : C'est la partie cruciale pour gérer les valeurs null. Nous vérifions si la variable nullMap est null avant d'essayer d'appeler des méthodes sur elle. Si elle est null, nous affichons un message. Si elle n'était pas null, le bloc else serait exécuté, et nous pourrions appeler en toute sécurité isEmpty() et size().
boolean isNullMapEmpty = (nullMap == null || nullMap.isEmpty()); : C'est un modèle courant pour vérifier si une carte est effectivement "vide", ce qui inclut le cas où la référence de la carte elle-même est null. L'opérateur || (OU) signifie que si nullMap == null est vrai, toute l'expression est vraie, et nullMap.isEmpty() n'est même pas évalué, évitant ainsi la NullPointerException.
int nullMapSize = (nullMap == null) ? 0 : nullMap.size(); : Cela utilise l'opérateur ternaire (? :) pour obtenir en toute sécurité la taille. Si nullMap est null, l'expression s'évalue à 0. Sinon, elle s'évalue à nullMap.size().

Enregistrez le fichier MapCheck.java (Ctrl+S ou Cmd+S).

Compilez le code modifié dans le terminal :

javac MapCheck.java

Exécutez le programme :

java MapCheck

Vous devriez voir une sortie similaire à celle-ci :

Size of the empty map: 0
Size of the non-empty map: 3
The nullMap is null.
Is the nullMap considered empty (including null)? true
Size of the nullMap (handling null): 0

Notez que les lignes à l'intérieur du bloc else pour nullMap n'ont pas été exécutées, et nous avons réussi à vérifier si nullMap était null et à obtenir sa taille (en considérant null comme ayant une taille de 0) sans causer d'erreur.

Gérer les références null est très important en Java pour éviter les NullPointerException et rendre vos programmes plus robustes. Pensez toujours à vérifier si une variable peut être null avant d'appeler des méthodes sur elle.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si une Map en Java est vide. Nous avons exploré la méthode principale pour cela, isEmpty(), qui indique directement si une carte contient des paires clé-valeur. Nous avons vu comment appliquer cette méthode à la fois aux cartes vides nouvellement créées et aux cartes qui ont été remplies de données, démontrant son utilisation simple et le résultat booléen qu'elle retourne.

Au-delà de la vérification de base avec isEmpty(), nous avons également abordé des méthodes alternatives telles que l'utilisation de size() pour déterminer si la taille d'une carte est nulle, ce qui est fonctionnellement équivalent à vérifier la vacuité. En outre, nous avons traité l'aspect crucial de la gestion des références potentielles de cartes null pour éviter les NullPointerException, en soulignant l'importance des vérifications de nullité avant d'essayer d'appeler des méthodes sur un objet de type carte.