So prüfen Sie, ob eine Map in Java einen bestimmten Schlüssel enthält

Einführung

In diesem Lab lernen Sie, wie Sie effektiv prüfen können, ob ein bestimmter Schlüssel in einer Java-Map vorhanden ist. Dies ist eine entscheidende Fähigkeit, um Fehler zu vermeiden und robuste Map-Operationen sicherzustellen.

Wir werden die grundlegende Methode containsKey() zur Prüfung der Schlüsselpräsenz untersuchen, ihre Verwendung mit verschiedenen Schlüsseltypen demonstrieren und darauf eingehen, wie Sie mit Null-Schlüsseln umgehen können. Dadurch erhalten Sie ein umfassendes Verständnis der Schlüsselprüfung in Java-Maps.

Verwenden Sie containsKey() zur Schlüsselprüfung

In diesem Schritt lernen wir, wie man mithilfe der Methode containsKey() prüft, ob ein bestimmter Schlüssel in einer HashMap vorhanden ist. Dies ist eine grundlegende Operation beim Arbeiten mit Maps und hilft Ihnen, Fehler zu vermeiden, die auftreten können, wenn Sie versuchen, auf einen nicht vorhandenen Schlüssel zuzugreifen.

Eine HashMap ist eine Datenstruktur in Java, die Schlüssel-Wert-Paare speichert. Stellen Sie sich dies wie ein Wörterbuch vor, bei dem jedes Wort (der Schlüssel) eine Definition (der Wert) hat. Die Methode containsKey() ist wie die Frage an das Wörterbuch: "Hast du einen Eintrag für dieses bestimmte Wort?"

Lassen Sie uns ein einfaches Java-Programm erstellen, um zu zeigen, wie man containsKey() verwendet.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor. Wenn Sie das vorherige Lab abgeschlossen haben, sollte diese Datei bereits im Verzeichnis ~/project vorhanden sein.

Ersetzen Sie den vorhandenen Code in HelloJava.java durch folgenden Code:

import java.util.HashMap;

public class HelloJava {
    public static void main(String[] args) {
        // Create a HashMap
        HashMap<String, String> userMap = new HashMap<>();

        // Add some key-value pairs
        userMap.put("alice", "Alice Smith");
        userMap.put("bob", "Bob Johnson");
        userMap.put("charlie", "Charlie Brown");

        // Check if a key exists using containsKey()
        String keyToCheck1 = "alice";
        String keyToCheck2 = "david";

        System.out.println("Checking for key: " + keyToCheck1);
        if (userMap.containsKey(keyToCheck1)) {
            System.out.println("Key '" + keyToCheck1 + "' exists in the map.");
        } else {
            System.out.println("Key '" + keyToCheck1 + "' does not exist in the map.");
        }

        System.out.println("\nChecking for key: " + keyToCheck2);
        if (userMap.containsKey(keyToCheck2)) {
            System.out.println("Key '" + keyToCheck2 + "' exists in the map.");
        } else {
            System.out.println("Key '" + keyToCheck2 + "' does not exist in the map.");
        }
    }
}

Schauen wir uns die neuen Teile dieses Codes an:

import java.util.HashMap;: Diese Zeile importiert die HashMap-Klasse, die wir benötigen, um HashMaps zu verwenden.
HashMap<String, String> userMap = new HashMap<>();: Diese Zeile erstellt eine neue HashMap, bei der sowohl die Schlüssel als auch die Werte vom Typ String sind.
userMap.put("alice", "Alice Smith");: Dies fügt ein Schlüssel-Wert-Paar zur Map hinzu. Der Schlüssel ist "alice" und der Wert ist "Alice Smith".
userMap.containsKey(keyToCheck1): Dies ist der Kern dieses Schritts. Die Methode containsKey() nimmt einen Schlüssel als Argument entgegen und gibt true zurück, wenn der Schlüssel in der Map gefunden wird, und false sonst.

Speichern Sie die Datei HelloJava.java (Strg+S oder Cmd+S).
Kompilieren Sie jetzt das Programm mit dem Befehl javac im Terminal:
```
javac HelloJava.java
```
Wenn keine Fehler auftreten, sehen Sie keine Ausgabe.

Führen Sie schließlich das kompilierte Programm mit dem Befehl java aus:

java HelloJava

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Checking for key: alice
Key 'alice' exists in the map.

Checking for key: david
Key 'david' does not exist in the map.

Diese Ausgabe bestätigt, dass containsKey() korrekt erkannt hat, ob die Schlüssel "alice" und "david" in unserer userMap vorhanden waren.

Testen mit verschiedenen Schlüsseltypen

Im vorherigen Schritt haben wir String-Schlüssel in unserer HashMap verwendet. Allerdings kann eine HashMap verschiedene Datentypen als Schlüssel nutzen, solange es sich um Objekte handelt (primitive Datentypen wie int, char usw. werden automatisch in ihre entsprechenden Objekt-Wrapper wie Integer, Character "verpackt").

In diesem Schritt werden wir untersuchen, wie man verschiedene Datentypen als Schlüssel in einer HashMap verwendet und wie containsKey() mit ihnen funktioniert.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

Ersetzen Sie den vorhandenen Code durch folgenden:

import java.util.HashMap;

public class HelloJava {
    public static void main(String[] args) {
        // Create a HashMap with Integer keys and String values
        HashMap<Integer, String> studentMap = new HashMap<>();

        // Add some key-value pairs
        studentMap.put(101, "Alice Smith");
        studentMap.put(102, "Bob Johnson");
        studentMap.put(103, "Charlie Brown");

        // Check for keys using containsKey() with Integer keys
        Integer keyToCheck1 = 101;
        Integer keyToCheck2 = 200; // A key that does not exist

        System.out.println("Checking for key: " + keyToCheck1);
        if (studentMap.containsKey(keyToCheck1)) {
            System.out.println("Key '" + keyToCheck1 + "' exists in the map.");
        } else {
            System.out.println("Key '" + keyToCheck1 + "' does not exist in the map.");
        }

        System.out.println("\nChecking for key: " + keyToCheck2);
        if (studentMap.containsKey(keyToCheck2)) {
            System.out.println("Key '" + keyToCheck2 + "' exists in the map.");
        } else {
            System.out.println("Key '" + keyToCheck2 + "' does not exist in the map.");
        }

        // You can also use primitive int directly, Java will auto-box it
        int primitiveKey = 102;
        System.out.println("\nChecking for primitive key: " + primitiveKey);
        if (studentMap.containsKey(primitiveKey)) {
             System.out.println("Key '" + primitiveKey + "' exists in the map.");
        } else {
             System.out.println("Key '" + primitiveKey + "' does not exist in the map.");
        }
    }
}

In diesem Code haben wir eine HashMap erstellt, bei der die Schlüssel Integer-Objekte (repräsentieren Studenten-IDs) und die Werte String-Objekte (repräsentieren Studentennamen) sind. Anschließend verwenden wir containsKey() sowohl mit Integer-Objekten als auch mit einem primitiven int, um zu zeigen, dass Java die Konvertierung (Auto-Boxing) für Sie vornimmt.

Speichern Sie die Datei HelloJava.java.
Kompilieren Sie das Programm:
```
javac HelloJava.java
```

Führen Sie das Programm aus:

java HelloJava

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Checking for key: 101
Key '101' exists in the map.

Checking for key: 200
Key '200' does not exist in the map.

Checking for primitive key: 102
Key '102' exists in the map.

Dies zeigt, dass containsKey() korrekt mit Integer-Schlüsseln funktioniert und dass Java's Auto-Boxing-Funktion es Ihnen ermöglicht, primitive int-Werte direkt beim Prüfen auf Schlüssel in einer HashMap<Integer, ...> zu verwenden.

Behandlung von Null-Schlüsseln

In Java's HashMap können Sie tatsächlich null als Schlüssel verwenden, aber es ist nur ein null-Schlüssel erlaubt. Es ist wichtig zu verstehen, wie containsKey() bei der Behandlung von null-Schlüsseln verhält.

In diesem Schritt werden wir unser Programm so ändern, dass es einen null-Schlüssel enthält und dann containsKey() verwenden, um auf seine Existenz zu prüfen.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

Ersetzen Sie den vorhandenen Code durch folgenden:

import java.util.HashMap;

public class HelloJava {
    public static void main(String[] args) {
        // Create a HashMap that allows null keys
        HashMap<String, String> statusMap = new HashMap<>();

        // Add some key-value pairs, including a null key
        statusMap.put("active", "User is currently online");
        statusMap.put("inactive", "User is offline");
        statusMap.put(null, "User status is unknown"); // Adding a null key

        // Check for keys using containsKey(), including null
        String keyToCheck1 = "active";
        String keyToCheck2 = "pending"; // A key that does not exist
        String keyToCheck3 = null;      // The null key

        System.out.println("Checking for key: " + keyToCheck1);
        if (statusMap.containsKey(keyToCheck1)) {
            System.out.println("Key '" + keyToCheck1 + "' exists in the map.");
        } else {
            System.out.println("Key '" + keyToCheck1 + "' does not exist in the map.");
        }

        System.out.println("\nChecking for key: " + keyToCheck2);
        if (statusMap.containsKey(keyToCheck2)) {
            System.out.println("Key '" + keyToCheck2 + "' exists in the map.");
        } else {
            System.out.println("Key '" + keyToCheck2 + "' does not exist in the map.");
        }

        System.out.println("\nChecking for null key:");
        if (statusMap.containsKey(keyToCheck3)) {
            System.out.println("Null key exists in the map.");
        } else {
            System.out.println("Null key does not exist in the map.");
        }
    }
}

Hier haben wir eine HashMap mit String-Schlüsseln und -Werten erstellt. Anschließend fügen wir explizit einen null-Schlüssel mit statusMap.put(null, "User status is unknown"); hinzu. Schließlich verwenden wir containsKey(null), um zu prüfen, ob der null-Schlüssel vorhanden ist.

Speichern Sie die Datei HelloJava.java.
Kompilieren Sie das Programm:
```
javac HelloJava.java
```

Führen Sie das Programm aus:

java HelloJava

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Checking for key: active
Key 'active' exists in the map.

Checking for key: pending
Key 'pending' does not exist in the map.

Checking for null key:
Null key exists in the map.

Diese Ausgabe bestätigt, dass containsKey() die Existenz des null-Schlüssels in der HashMap korrekt erkennt. Obwohl die Verwendung von null-Schlüsseln möglich ist, wird es oft empfohlen, sie wenn möglich zu vermeiden, um den Code klarer zu gestalten und potenzielle NullPointerException-Probleme in anderen Teilen des Programms zu vermeiden.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man mithilfe der Methode containsKey() prüft, ob ein bestimmter Schlüssel in einer Java-HashMap existiert. Diese grundlegende Operation ist entscheidend, um Fehler beim Zugriff auf Karten-Elemente (Map-Elemente) zu vermeiden. Wir haben die Verwendung von containsKey() mit String-Schlüsseln geübt und beobachtet, wie es vorhandene und nicht vorhandene Schlüssel korrekt erkennt.