Wie man prüft, ob eine Map in Java einen bestimmten Wert enthält

Einführung

In diesem Lab werden Sie lernen, wie Sie prüfen können, ob ein bestimmter Wert in einer HashMap in Java vorhanden ist. Wir werden die praktische containsValue()-Methode untersuchen, die von der HashMap-Klasse bereitgestellt wird und effizient feststellt, ob ein Wert vorhanden ist.

Darüber hinaus werden wir untersuchen, wie man manuell durch die Werte der Map iteriert, um die Prüfung durchzuführen, was einen alternativen Ansatz bietet. Schließlich werden wir besprechen, wie man Null-Werte behandelt, wenn man prüft, ob sie in der Map vorhanden sind.

Verwenden Sie containsValue() zur Wertprüfung

In diesem Schritt werden wir untersuchen, wie man prüft, ob ein bestimmter Wert in einer HashMap in Java vorhanden ist. HashMap ist eine sehr nützliche Datenstruktur, die Schlüssel-Wert-Paare speichert. Manchmal müssen Sie möglicherweise wissen, ob ein bestimmter Wert in der Map vorhanden ist, unabhängig von seinem Schlüssel.

Java's HashMap-Klasse bietet für diesen Zweck eine praktische Methode namens containsValue(). Diese Methode nimmt einen Wert als Argument entgegen und gibt true zurück, wenn die Map mindestens ein Schlüssel-Wert-Paar enthält, bei dem der Wert gleich dem angegebenen Wert ist. Andernfalls gibt sie false zurück.

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

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.
Ersetzen Sie den gesamten Inhalt der Datei durch folgenden Code:
```
import java.util.HashMap;

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

        // Add some key-value pairs
        ages.put("Alice", 30);
        ages.put("Bob", 25);
        ages.put("Charlie", 35);
        ages.put("David", 25); // Another person with age 25

        // Check if a specific value exists
        int valueToCheck = 25;
        boolean contains25 = ages.containsValue(valueToCheck);

        System.out.println("Does the map contain the value " + valueToCheck + "? " + contains25);

        valueToCheck = 40;
        boolean contains40 = ages.containsValue(valueToCheck);
        System.out.println("Does the map contain the value " + valueToCheck + "? " + contains40);
    }
}
```
Schauen wir uns die neuen Teile dieses Codes an:
- import java.util.HashMap;: Diese Zeile importiert die HashMap-Klasse, die wir verwenden müssen.
- HashMap<String, Integer> ages = new HashMap<>();: Diese Zeile erstellt eine neue HashMap, bei der die Schlüssel String (z.B. Namen) und die Werte Integer (z.B. Alter) sind.
- ages.put("Alice", 30); und ähnliche Zeilen: Diese Zeilen fügen Schlüssel-Wert-Paare zur HashMap hinzu.
- int valueToCheck = 25;: Dies deklariert eine Ganzzahlvariable valueToCheck und weist ihr den Wert 25 zu.
- boolean contains25 = ages.containsValue(valueToCheck);: Hier verwenden wir die containsValue()-Methode. Sie prüft, ob der in valueToCheck gespeicherte Wert (der 25 ist) irgendwo in den Werten der ages-Map vorhanden ist. Das Ergebnis (true oder false) wird in der booleschen Variable contains25 gespeichert.
- System.out.println(...): Diese Zeilen geben die Ergebnisse in die Konsole aus.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm in der Terminal:
```
javac HelloJava.java
```
Wenn keine Fehler auftreten, wird eine HelloJava.class-Datei erstellt.
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe sehen, die angibt, ob die Werte 25 und 40 in der Map vorhanden sind.
```
Does the map contain the value 25? true
Does the map contain the value 40? false
```

Dies zeigt, wie einfach Sie mithilfe der containsValue()-Methode prüfen können, ob ein Wert in einer HashMap vorhanden ist.

Manuell durch die Werte iterieren

Im vorherigen Schritt haben wir die integrierte containsValue()-Methode verwendet, um auf einen Wert zu prüfen. Dies ist zwar die effizienteste Methode, aber es ist auch hilfreich, zu verstehen, wie man manuell auf einen Wert prüfen kann, indem man alle Werte in der HashMap durchläuft. Dieser Prozess umfasst das Abrufen einer Sammlung aller Werte und das anschließende nacheinander Durchlaufen dieser Werte.

Java's HashMap bietet eine Methode namens values(), die eine Collection-Ansicht der in der Map enthaltenen Werte zurückgibt. Wir können dann mithilfe einer Schleife über diese Collection iterieren.

Lassen Sie uns unser Programm ändern, um manuell zu prüfen, ob der Wert 25 vorhanden ist, indem wir die Werte durchlaufen.

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

Ersetzen Sie den vorhandenen Code durch folgenden:

import java.util.HashMap;
import java.util.Collection;

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

        // Add some key-value pairs
        ages.put("Alice", 30);
        ages.put("Bob", 25);
        ages.put("Charlie", 35);
        ages.put("David", 25); // Another person with age 25

        // Get a collection of all values
        Collection<Integer> allAges = ages.values();

        // Manually check if a specific value exists by looping
        int valueToCheck = 25;
        boolean foundManually = false;

        for (Integer age : allAges) {
            if (age.equals(valueToCheck)) {
                foundManually = true;
                break; // Exit the loop once the value is found
            }
        }

        System.out.println("Does the map contain the value " + valueToCheck + " (manual check)? " + foundManually);

        valueToCheck = 40;
        foundManually = false; // Reset for the next check

        for (Integer age : allAges) {
             if (age.equals(valueToCheck)) {
                foundManually = true;
                break;
            }
        }
         System.out.println("Does the map contain the value " + valueToCheck + " (manual check)? " + foundManually);
    }
}

Hier ist, was neu oder geändert ist:

import java.util.Collection;: Wir importieren das Collection-Interface, weil ages.values() eine Collection zurückgibt.
Collection<Integer> allAges = ages.values();: Diese Zeile ruft eine Collection ab, die alle ganzzahligen Werte (Alter) aus unserer ages-Map enthält.
for (Integer age : allAges): Dies ist eine erweiterte for-Schleife (auch als for-each-Schleife bekannt), die durch jedes Integer-Element in der allAges-Sammlung iteriert. Bei jeder Iteration wird der aktuelle Wert der age-Variable zugewiesen.
if (age.equals(valueToCheck)): Innerhalb der Schleife vergleichen wir das aktuelle age mit dem valueToCheck. Wir verwenden equals() zum Vergleichen von Objekten (wie Integer), was im Allgemeinen sicherer ist als der Einsatz von == für Objekte.
foundManually = true;: Wenn eine Übereinstimmung gefunden wird, setzen wir foundManually auf true.
break;: Diese Anweisung beendet die Schleife sofort, sobald der Wert gefunden wird, was die Prüfung effizienter macht.

Speichern Sie die Datei.
Kompilieren Sie das Programm:
```
javac HelloJava.java
```
Führen Sie das Programm aus:
```
java HelloJava
```
Die Ausgabe sollte die gleiche wie im vorherigen Schritt sein, was bestätigt, dass unsere manuelle Prüfung korrekt funktioniert.
```
Does the map contain the value 25 (manual check)? true
Does the map contain the value 40 (manual check)? false
```

Obwohl das manuelle Durchlaufen funktioniert, wird die Verwendung von containsValue() im Allgemeinen bevorzugt, da es kompakter ist und oft im Java-Bibliothek für die Leistung optimiert ist. Das Verständnis, wie man durch Werte iteriert, ist jedoch eine grundlegende Fähigkeit, die in vielen anderen Szenarien nützlich sein wird.

Null-Werte behandeln

In Java ist null ein spezieller Wert, der "kein Objekt" bedeutet. Es ist wichtig zu verstehen, wie HashMap null-Werte behandelt und wie containsValue() bei der Arbeit mit null verhält.

Eine HashMap in Java kann null-Werte speichern. Sie können eine Zuordnung hinzufügen, bei der der Wert null ist.

Lassen Sie uns unser Programm ändern, um einen null-Wert einzubeziehen und zu sehen, wie containsValue() damit 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
        HashMap<String, Integer> ages = new HashMap<>();

        // Add some key-value pairs, including a null value
        ages.put("Alice", 30);
        ages.put("Bob", 25);
        ages.put("Charlie", null); // Charlie's age is unknown (null)
        ages.put("David", 25);

        // Check if a specific value exists, including null
        int valueToCheck = 25;
        boolean contains25 = ages.containsValue(valueToCheck);
        System.out.println("Does the map contain the value " + valueToCheck + "? " + contains25);

        Integer nullValue = null;
        boolean containsNull = ages.containsValue(nullValue);
        System.out.println("Does the map contain the value null? " + containsNull);

        valueToCheck = 40;
        boolean contains40 = ages.containsValue(valueToCheck);
        System.out.println("Does the map contain the value " + valueToCheck + "? " + contains40);
    }
}

Hier ist die wichtigste Änderung:

ages.put("Charlie", null);: Wir haben eine Zuordnung hinzugefügt, bei der der Schlüssel "Charlie" einem null-Wert zugeordnet ist.
Integer nullValue = null;: Wir erstellen eine Integer-Variable und weisen ihr den Wert null zu.
boolean containsNull = ages.containsValue(nullValue);: Wir verwenden containsValue(), um zu prüfen, ob die Map den null-Wert enthält.

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

Führen Sie das Programm aus:

java HelloJava

Beobachten Sie die Ausgabe, insbesondere die Zeile, die auf null prüft.

Does the map contain the value 25? true
Does the map contain the value null? true
Does the map contain the value 40? false

Wie Sie sehen können, erkennt containsValue() korrekt, dass die HashMap den null-Wert enthält, da wir ihn explizit hinzugefügt haben. Dies bestätigt, dass HashMap null-Werte speichern kann und containsValue() verwendet werden kann, um auf deren Vorhandensein zu prüfen.

Der Umgang mit null-Werten ist ein wichtiger Aspekt der Java-Programmierung. Seien Sie immer darauf bedacht, ob Ihre Datenstrukturen möglicherweise null enthalten und wie Ihr Code in solchen Fällen verhalten wird.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob eine HashMap in Java einen bestimmten Wert enthält. Die hauptsächlich untersuchte Methode war containsValue(), die eine einfache Möglichkeit bietet, die Anwesenheit eines Werts in der Map festzustellen. Wir haben gesehen, wie man diese Methode anhand eines einfachen Beispiels verwendet und wie ihr Rückgabewert davon abhängt, ob der Zielwert in der Map vorhanden ist.

Wir haben auch alternative Methoden zur Prüfung der Wertanwesenheit untersucht, wie etwa das manuelle Durchlaufen der Werte der Map. Darüber hinaus wurde im Lab behandelt, wie man mit Nullwerten umgeht, wenn man prüft, ob sie in der Map vorhanden sind, um ein umfassendes Verständnis der Wertprüfung in HashMap zu gewährleisten.