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

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob ein bestimmtes Element in einer Java-List vorhanden ist. Wir werden verschiedene Methoden untersuchen, um diese häufige Aufgabe bei der Arbeit mit Datensammlungen auszuführen.

Zunächst lernen Sie, die praktische contains()-Methode zu verwenden, die von der List-Schnittstelle (Interface) bereitgestellt wird. Danach verstehen Sie, wie Sie manuell durch eine Liste iterieren können, um nach einem Element zu suchen, was in bestimmten Szenarien nützlich sein kann. Abschließend behandeln wir, wie Sie das Vorhandensein von null-Elementen in Ihrer Liste bei diesen Prüfungen behandeln können.

Skills Graph

Verwendung von contains() zur Elementprüfung

In diesem Schritt lernen wir, wie man prüft, ob ein bestimmtes Element in einer Java-List vorhanden ist, indem man die contains()-Methode verwendet. Dies ist eine häufige Aufgabe bei der Arbeit mit Datensammlungen.

Zunächst erstellen wir eine neue Java-Datei namens ListContains.java im Verzeichnis ~/project. Sie können dies tun, indem Sie mit der rechten Maustaste im Dateiexplorer links klicken und "Neue Datei" auswählen, und dann ListContains.java eingeben.

Öffnen Sie jetzt die Datei ListContains.java im Editor und fügen Sie folgenden Code hinzu:

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

public class ListContains {

    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 Code analysieren:

• import java.util.ArrayList; und import java.util.List;: Diese Zeilen importieren die erforderlichen Klassen, um mit Listen (Lists) zu arbeiten.
• List<String> fruits = new ArrayList<>();: Diese Zeile erstellt eine neue ArrayList, die eine Art von List ist, die String-Objekte enthalten kann.
• fruits.add("...");: Diese Zeilen fügen Elemente (Fruchtnamen) zu unserer Liste hinzu.
• fruits.contains("Banana");: Dies ist der Kern dieses Schritts. Die contains()-Methode wird auf der fruits-Liste aufgerufen. Sie nimmt ein Argument entgegen, das Element, nach dem wir suchen möchten. Sie gibt true zurück, wenn das Element in der Liste gefunden wird, und false sonst.
• boolean hasBanana = ...;: Das Ergebnis von contains() wird in einer booleschen Variablen (hasBanana oder hasGrape) gespeichert.
• System.out.println("...");: Diese Zeilen geben die Ergebnisse in die Konsole aus.

Speichern Sie die Datei ListContains.java (Strg+S oder Cmd+S).

Öffnen Sie jetzt das Terminal unten im WebIDE. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Wenn nicht, geben Sie cd ~/project ein und drücken Sie die Eingabetaste.

Kompilieren Sie den Java-Code mit dem Befehl javac:

javac ListContains.java

Wenn keine Fehler auftreten, wird im Verzeichnis ~/project eine Datei namens ListContains.class erstellt.

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

java ListContains

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 contains()-Methode korrekt erkannt hat, ob "Banana" und "Grape" in unserer Liste vorhanden waren.

Manuelles Durchlaufen einer Liste

Im vorherigen Schritt haben wir die contains()-Methode verwendet, um nach einem Element zu suchen. Obwohl contains() praktisch ist, müssen Sie manchmal jedes Element in einer Liste einzeln untersuchen. Dies wird als Iterieren oder Durchlaufen einer Liste bezeichnet. In diesem Schritt lernen wir, wie man dies mit einer for-Schleife macht.

Öffnen Sie die Datei ListContains.java im Verzeichnis ~/project im WebIDE-Editor.

Wir werden den bestehenden Code ändern, um die fruits-Liste zu durchlaufen und jedes Element auszugeben. Ersetzen Sie die bestehende main-Methode durch folgenden Code:

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

public class ListContains {

    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");

        // Loop through the list using a for loop
        System.out.println("Printing fruits in the list:");
        for (int i = 0; i < fruits.size(); i++) {
            String fruit = fruits.get(i);
            System.out.println(fruit);
        }
    }
}

Schauen wir uns die neuen Teile an:

• System.out.println("Printing fruits in the list:");: Diese Zeile gibt einfach einen Titel aus, bevor wir mit der Auflistung der Früchte beginnen.
• for (int i = 0; i < fruits.size(); i++): Dies ist eine Standard-for-Schleife.
  • int i = 0: Wir starten eine Zählervariable i mit dem Wert 0. In der Programmierung beginnt man oft mit der Zählung bei 0.
  • i < fruits.size(): Die Schleife läuft so lange, wie i kleiner als die Gesamtzahl der Elemente in der fruits-Liste ist. fruits.size() gibt uns die Anzahl der Elemente.
  • i++: Nach jedem Durchlauf der Schleife erhöhen wir den Wert von i um 1.
• String fruit = fruits.get(i);: Innerhalb der Schleife ruft fruits.get(i) das Element an der aktuellen Position i aus der Liste ab. Wir speichern dieses Element in einer String-Variable namens fruit.
• System.out.println(fruit);: Diese Zeile gibt die aktuelle fruit in die Konsole aus.

Speichern Sie die Datei ListContains.java.

Jetzt kompilieren Sie den geänderten Code im Terminal:

javac ListContains.java

Wenn die Kompilierung erfolgreich ist, führen Sie das Programm aus:

java ListContains

Sie sollten die folgende Ausgabe sehen:

Printing fruits in the list:
Apple
Banana
Orange
Mango

Dies zeigt, dass unsere for-Schleife die Liste erfolgreich durchlaufen hat und jede Frucht in einer neuen Zeile ausgegeben hat. Das manuelle Durchlaufen einer Liste auf diese Weise gibt Ihnen mehr Kontrolle darüber, wie Sie jedes Element verarbeiten, was für komplexere Aufgaben als nur das Prüfen auf Existenz nützlich sein kann.

Umgang mit Null-Elementen in einer Liste

In der realen Welt können Listen manchmal "null"-Werte enthalten, die das Fehlen eines Wertes repräsentieren. Wenn Sie versuchen, Operationen an einem Null-Wert auszuführen, ohne zu prüfen, kann Ihr Programm mit einer NullPointerException abstürzen. In diesem Schritt lernen wir, wie man Null-Elemente beim Durchlaufen einer Liste behandelt.

Öffnen Sie die Datei ListContains.java im Verzeichnis ~/project im WebIDE-Editor.

Wir werden den Code ändern, um ein null-Element zur Liste hinzuzufügen und dann innerhalb der Schleife auf Null zu prüfen. Ersetzen Sie die bestehende main-Methode durch folgenden Code:

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

public class ListContains {

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

        // Add some fruits to the list, including a null
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add(null); // Adding a null element
        fruits.add("Orange");
        fruits.add("Mango");

        // Loop through the list and handle null elements
        System.out.println("Printing fruits in the list (handling nulls):");
        for (int i = 0; i < fruits.size(); i++) {
            String fruit = fruits.get(i);

            // Check if the element is null before processing
            if (fruit != null) {
                System.out.println(fruit);
            } else {
                System.out.println("Found a null element");
            }
        }
    }
}

Hier ist, was wir geändert haben:

• fruits.add(null);: Wir haben einen null-Wert zur Liste hinzugefügt.
• if (fruit != null): Innerhalb der Schleife fügen wir vor dem Versuch, die fruit auszugeben, eine if-Anweisung hinzu, um zu prüfen, ob die Variable fruit nicht null ist.
• System.out.println(fruit);: Diese Zeile befindet sich innerhalb des if-Blocks, sodass sie nur ausgeführt wird, wenn fruit nicht null ist.
• else { System.out.println("Found a null element"); }: Dieser else-Block wird ausgeführt, wenn fruit null ist und gibt eine Nachricht aus, anstatt zu versuchen, den Null-Wert selbst auszugeben.

Speichern Sie die Datei ListContains.java.

Kompilieren Sie den geänderten Code im Terminal:

javac ListContains.java

Wenn die Kompilierung erfolgreich ist, führen Sie das Programm aus:

java ListContains

Sie sollten die folgende Ausgabe sehen:

Printing fruits in the list (handling nulls):
Apple
Banana
Found a null element
Orange
Mango

Wie Sie sehen können, erkennt und behandelt das Programm jetzt das Null-Element korrekt, ohne abzustürzen. Das Prüfen auf Null ist eine entscheidende Praxis in der Java-Programmierung, um Fehler zu vermeiden und Ihre Programme robuster zu machen.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob eine Java-List ein bestimmtes Element enthält. Zunächst haben wir die einfachste Methode untersucht, indem wir die integrierte contains()-Methode verwendet haben, die effizient feststellt, ob ein Element vorhanden ist, und ein boolesches Ergebnis zurückgibt.

Anschließend haben wir uns mit dem manuellen Durchlaufen der Liste zur Prüfung beschäftigt, um ein tieferes Verständnis dafür zu erhalten, wie die contains()-Methode intern funktionieren könnte. Schließlich haben wir die wichtige Überlegung behandelt, Null-Elemente innerhalb der Liste bei diesen Prüfungen zu verarbeiten, um robusten und fehlerfreien Code zu gewährleisten.