Wie man prüft, ob ein Set in Java ein bestimmtes Element enthält

Einführung

In diesem Lab werden Sie lernen, wie Sie prüfen können, ob ein bestimmtes Element in einer Sammlung in Java vorhanden ist. Wir werden uns auf die Verwendung der Methode contains() konzentrieren, die für alle Sammlungsarten verfügbar ist. Sie werden die Verwendung von contains() mit verschiedenen Elementtypen üben und lernen, wie Sie Null-Elemente behandeln. Am Ende dieses Labs können Sie die Anwesenheit von Elementen in Java-Sammlungen sicher bestimmen.

Verwenden Sie contains() zur Elementprüfung

In diesem Schritt werden wir untersuchen, wie man prüft, ob ein bestimmtes Element in einer Sammlung in Java vorhanden ist. Sammlungen sind grundlegende Datenstrukturen, die verwendet werden, um mehrere Elemente zu einer Einheit zusammenzufassen. Java bietet verschiedene Arten von Sammlungen, wie Listen (Lists), Mengen (Sets) und Maps.

Eine häufige Aufgabe beim Arbeiten mit Sammlungen besteht darin, festzustellen, ob ein bestimmtes Element vorhanden ist. Java's Collection-Schnittstelle, die die Basisschnittstelle für alle Sammlungsarten ist, bietet eine bequeme Methode für diesen Zweck: contains().

Die Methode contains() nimmt ein Argument entgegen, das Element, nach dem Sie suchen, und gibt einen booleschen Wert zurück: true, wenn das Element in der Sammlung gefunden wird, und false sonst.

Lassen Sie uns ein einfaches Java-Programm erstellen, um zu demonstrieren, wie man die Methode contains() mit einer ArrayList verwendet, die eine häufige Art von Liste ist.

Ö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.ArrayList;
import java.util.List;

public class HelloJava {
    public static void main(String[] args) {
        // Create a List of strings
        List<String> fruits = new ArrayList<>();

        // Add some fruits to the list
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        fruits.add("Mango");

        // Check if the list contains "Banana"
        boolean hasBanana = fruits.contains("Banana");
        System.out.println("Does the list contain Banana? " + hasBanana);

        // Check if the list contains "Grape"
        boolean hasGrape = fruits.contains("Grape");
        System.out.println("Does the list contain Grape? " + hasGrape);
    }
}
```
Lassen Sie uns diesen neuen Code analysieren:
- import java.util.ArrayList; und import java.util.List;: Diese Zeilen importieren die notwendigen Klassen, um mit Listen und ArrayLists zu arbeiten.
- List<String> fruits = new ArrayList<>();: Diese Zeile erstellt eine neue ArrayList, die String-Objekte aufnehmen kann, und weist sie einer Variablen namens fruits zu.
- fruits.add("Apple"); und ähnliche Zeilen: Diese Zeilen fügen Elemente (Strings, die Fruchtnamen repräsentieren) zu unserer fruits-Liste hinzu.
- boolean hasBanana = fruits.contains("Banana");: Diese Zeile ruft die Methode contains() auf der fruits-Liste auf und prüft, ob der String "Banana" vorhanden ist. Das Ergebnis (true oder false) wird in einer booleschen Variablen hasBanana gespeichert.
- System.out.println("Does the list contain Banana? " + hasBanana);: Diese Zeile gibt das Ergebnis der Prüfung auf "Banana" aus.
- boolean hasGrape = fruits.contains("Grape"); und die folgende println-Zeile: Diese Zeilen führen die gleiche Prüfung für "Grape" durch, das nicht in unserer Liste ist.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Does the list contain Banana? true
Does the list contain Grape? false
```

Diese Ausgabe bestätigt, dass die Methode contains() korrekt erkannt hat, dass "Banana" in der Liste ist und "Grape" nicht.

Das Verständnis, wie man die Anwesenheit von Elementen prüft, ist eine grundlegende Fähigkeit beim Arbeiten mit Sammlungen in Java. In den nächsten Schritten werden wir weitere Aspekte der Methode contains() untersuchen und wie sie in verschiedenen Szenarien verhält.

Testen mit verschiedenen Elementtypen

Im vorherigen Schritt haben wir die Methode contains() mit einer List von String-Objekten verwendet. Die Methode contains() ist vielseitig und kann mit Sammlungen verwendet werden, die verschiedene Elementtypen speichern, wie Zahlen, benutzerdefinierte Objekte oder sogar andere Sammlungen.

Bei der Verwendung von contains() stützt sich Java auf die equals()-Methode der Objekte in der Sammlung, um zu bestimmen, ob das gesuchte Element übereinstimmt. Bei primitiven Typen (wie int, double, boolean) werden die entsprechenden Wrapper-Klassen (Integer, Double, Boolean) verwendet, und ihre equals()-Methoden vergleichen die Werte. Bei Objekten prüft die Standard-equals()-Methode, ob die beiden Objekt-Referenzen auf die gleiche Speicheradresse verweisen. Viele Klassen (wie String, Integer usw.) überschreiben jedoch die equals()-Methode, um den tatsächlichen Inhalt oder Wert der Objekte zu vergleichen.

Lassen Sie uns unser Programm so ändern, dass es mit einer List von Integer-Objekten arbeitet und sehen, wie contains() sich verhält.

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

Ersetzen Sie den aktuellen Code durch folgenden:

import java.util.ArrayList;
import java.util.List;

public class HelloJava {
    public static void main(String[] args) {
        // Create a List of integers
        List<Integer> numbers = new ArrayList<>();

        // Add some numbers to the list
        numbers.add(10);
        numbers.add(25);
        numbers.add(5);
        numbers.add(50);

        // Check if the list contains 25
        boolean hasTwentyFive = numbers.contains(25);
        System.out.println("Does the list contain 25? " + hasTwentyFive);

        // Check if the list contains 100
        boolean hasOneHundred = numbers.contains(100);
        System.out.println("Does the list contain 100? " + hasOneHundred);

        // Check if the list contains the Integer object with value 5
        boolean hasFiveObject = numbers.contains(Integer.valueOf(5));
        System.out.println("Does the list contain Integer object with value 5? " + hasFiveObject);
    }
}

In diesem Code:

Wir erstellen eine List, die speziell Integer-Objekte enthält: List<Integer> numbers = new ArrayList<>();.
Wir fügen ganzzahlige Werte der Liste mit numbers.add() hinzu. Java konvertiert automatisch die primitiven int-Werte (10, 25, 5, 50) in Integer-Objekte (dies wird als Autoboxing bezeichnet).
Wir verwenden numbers.contains(25) und numbers.contains(100), um die Anwesenheit von ganzzahligen Werten zu prüfen. Auch hier wird Java die primitiven int-Werte 25 und 100 in Integer-Objekte umwandeln, bevor die Prüfung durchgeführt wird.
Wir erstellen auch explizit ein Integer-Objekt mit Integer.valueOf(5) und prüfen, ob die Liste dieses spezifische Objekt enthält.

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

Führen Sie das Programm aus:

java HelloJava

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Does the list contain 25? true
Does the list contain 100? false
Does the list contain Integer object with value 5? true

Dies zeigt, dass contains() korrekt mit Integer-Objekten funktioniert und ihre Werte vergleicht. Die Methode contains() nutzt effektiv die equals()-Methode der Elemente in der Sammlung und des gesuchten Elements.

Im nächsten Schritt werden wir einen speziellen Fall untersuchen: die Behandlung von null-Elementen mit der Methode contains().

Umgang mit Null-Elementen

In Java können Sammlungen manchmal null-Elemente enthalten. Es ist wichtig zu verstehen, wie die contains()-Methode bei der Behandlung von null-Werten verhält.

Die gute Nachricht ist, dass die contains()-Methode so konzipiert ist, dass sie null-Elemente problemlos verarbeiten kann. Wenn eine Sammlung null enthält, gibt der Aufruf von contains(null) true zurück. Wenn die Sammlung kein null enthält, gibt es false zurück. Dies stimmt mit der allgemeinen Implementierung von equals() für null überein (die equals(null)-Methode eines beliebigen Objekts sollte false zurückgeben, aber null.equals(anyObject) würde eine NullPointerException werfen, wenn dies nicht intern von der contains-Implementierung der Sammlung behandelt wird).

Lassen Sie uns unser Programm so ändern, dass es null-Elemente enthält und prüft.

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

Ersetzen Sie den aktuellen Code durch folgenden:

import java.util.ArrayList;
import java.util.List;

public class HelloJava {
    public static void main(String[] args) {
        // Create a List that can contain null
        List<String> mixedList = new ArrayList<>();

        // Add some elements, including null
        mixedList.add("First");
        mixedList.add(null); // Adding a null element
        mixedList.add("Second");
        mixedList.add(null); // Adding another null element
        mixedList.add("Third");

        // Check if the list contains null
        boolean hasNull = mixedList.contains(null);
        System.out.println("Does the list contain null? " + hasNull);

        // Check if the list contains a non-existent element
        boolean hasFourth = mixedList.contains("Fourth");
        System.out.println("Does the list contain Fourth? " + hasFourth);

        // Check if the list contains "First"
        boolean hasFirst = mixedList.contains("First");
        System.out.println("Does the list contain First? " + hasFirst);
    }
}

In diesem Code:

Wir erstellen eine List namens mixedList.
Wir fügen einige String-Elemente hinzu und fügen auch explizit null mit mixedList.add(null); hinzu.
Wir verwenden dann mixedList.contains(null), um zu prüfen, ob die Liste den null-Wert enthält.
Wir führen auch Prüfungen für einen nicht vorhandenen String ("Fourth") und einen vorhandenen String ("First") durch, um die Ergebnisse neben der null-Prüfung zu sehen.

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

Führen Sie das Programm aus:

java HelloJava

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Does the list contain null? true
Does the list contain Fourth? false
Does the list contain First? true

Diese Ausgabe bestätigt, dass contains() die Anwesenheit von null in der Liste korrekt erkennt. Es ist wichtig zu wissen, dass Sammlungen null enthalten können (je nach spezieller Sammlungsart und ihrer Verwendung), und contains() bietet eine zuverlässige Möglichkeit, dies zu prüfen.

Sie haben nun gelernt, wie Sie die contains()-Methode verwenden, um nach Elementen in Java-Sammlungen zu suchen, einschließlich verschiedener Datentypen und dem speziellen Fall von null. Dies ist ein wertvolles Werkzeug für die Arbeit mit Sammlungen in Ihren Java-Programmen.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java prüft, ob eine Sammlung ein bestimmtes Element enthält, indem man die contains()-Methode verwendet. Wir haben gesehen, wie diese Methode, die über das Collection-Interface verfügbar ist, einen booleschen Wert zurückgibt, der die Anwesenheit des Elements angibt. Wir haben ihre Verwendung mit einer ArrayList demonstriert und beobachtet, wie sie vorhandene und nicht vorhandene Elemente korrekt erkennt.

Wir haben auch untersucht, wie die contains()-Methode mit verschiedenen Datentypen funktioniert und wie man Null-Elemente in einer Sammlung behandelt. Diese praktische Erfahrung hat uns ein praktisches Verständnis einer grundlegenden Operation bei der Arbeit mit Java-Sammlungen vermittelt.