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.
