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

Einführung

In diesem Lab lernen Sie, wie Sie mithilfe verschiedener Techniken prüfen können, ob ein bestimmtes Element in einem Java-Array vorhanden ist. Wir beginnen damit, den grundlegenden Ansatz zu erkunden, bei dem Sie mithilfe einer herkömmlichen for-Schleife durch das Array iterieren, um das Element zu suchen.

Nach der grundlegenden Iterationsmethode erfahren Sie, wie Sie die Arrays.stream()-Methode nutzen können, um auf eine kompaktere und möglicherweise effizientere Weise zu prüfen, ob ein Element vorhanden ist. Abschließend werden wir die wichtige Überlegung behandeln, wie Sie bei Ihren Suchvorgängen Null-Elemente (null elements) im Array behandeln.

Durchlaufen eines Arrays zur Suche nach einem Element

In diesem Schritt lernen Sie, wie Sie mithilfe einer herkömmlichen for-Schleife prüfen können, ob ein bestimmtes Element in einem Java-Array vorhanden ist. Dies ist eine grundlegende Technik zum Suchen in Datensammlungen.

Zunächst erstellen wir eine neue Java-Datei namens ArraySearch.java in Ihrem ~/project-Verzeichnis. Sie können dies entweder über den Dateiexplorer der WebIDE links tun oder indem Sie den folgenden Befehl im Terminal ausführen:

touch ~/project/ArraySearch.java

Öffnen Sie nun die Datei ArraySearch.java im WebIDE-Editor und fügen Sie den folgenden Java-Code hinzu:

public class ArraySearch {

    public static void main(String[] args) {
        // Define an array of strings
        String[] fruits = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};

        // The element we want to search for
        String searchElement = "Cherry";

        // Variable to keep track if the element is found
        boolean found = false;

        // Loop through the array
        for (int i = 0; i < fruits.length; i++) {
            // Check if the current element is equal to the search element
            if (fruits[i].equals(searchElement)) {
                found = true; // Element found
                break; // Exit the loop since we found the element
            }
        }

        // Print the result
        if (found) {
            System.out.println(searchElement + " was found in the array.");
        } else {
            System.out.println(searchElement + " was not found in the array.");
        }
    }
}

Lassen Sie uns diesen Code analysieren:

• String[] fruits = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};: Diese Zeile deklariert und initialisiert ein String-Array namens fruits mit mehreren Obstnamen.
• String searchElement = "Cherry";: Diese Zeile deklariert eine String-Variable searchElement und weist ihr den Wert "Cherry" zu. Dies ist das Element, das wir im Array suchen.
• boolean found = false;: Diese Zeile deklariert eine boolesche Variable found und initialisiert sie mit false. Wir setzen diese auf true, wenn wir das searchElement im Array finden.
• for (int i = 0; i < fruits.length; i++): Dies ist eine Standard-for-Schleife, die durch das Array iteriert. i beginnt bei 0 und geht bis (aber nicht einschließlich) der Länge des fruits-Arrays.
• if (fruits[i].equals(searchElement)): Innerhalb der Schleife prüft diese if-Anweisung, ob das aktuelle Element des Arrays (fruits[i]) gleich dem searchElement ist. Wir verwenden die .equals()-Methode, um Strings in Java zu vergleichen, nicht den ==-Operator.
• found = true;: Wenn die Elemente gleich sind, setzen wir die found-Variable auf true.
• break;: Sobald das Element gefunden wurde, verwenden wir die break-Anweisung, um die Schleife frühzeitig zu beenden, da es keinen Grund gibt, weiter zu suchen.
• Der abschließende if/else-Block gibt eine Nachricht aus, die angibt, ob das searchElement gefunden wurde, basierend auf dem Wert der found-Variable.

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

Jetzt kompilieren und führen wir das Programm im Terminal aus. Stellen Sie sicher, dass Sie sich im ~/project-Verzeichnis befinden.

Kompilieren Sie den Code:

javac ArraySearch.java

Wenn keine Fehler auftreten, wird eine ArraySearch.class-Datei erstellt.

Führen Sie den kompilierten Code aus:

java ArraySearch

Sie sollten die folgende Ausgabe sehen:

Cherry was found in the array.

Versuchen Sie nun, das searchElement in etwas zu ändern, das nicht im Array enthalten ist, wie z.B. "Grape", speichern Sie die Datei, kompilieren Sie erneut und führen Sie das Programm erneut aus, um die andere Ausgabe zu sehen.

Verwenden von Arrays.stream() zur Elementprüfung

In diesem Schritt lernen Sie eine modernere und oft kompaktere Methode kennen, um mithilfe der Streams-API, genauer gesagt Arrays.stream(), nach einem Element in einem Java-Array zu suchen. Dieser Ansatz nutzt Konzepte der funktionalen Programmierung und kann Ihren Code für bestimmte Aufgaben lesbarer machen.

Wir werden die ArraySearch.java-Datei, die Sie im vorherigen Schritt erstellt haben, ändern. Öffnen Sie ~/project/ArraySearch.java im WebIDE-Editor.

Ersetzen Sie den vorhandenen Code durch folgenden:

import java.util.Arrays;

public class ArraySearch {

    public static void main(String[] args) {
        // Define an array of strings
        String[] fruits = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};

        // The element we want to search for
        String searchElement = "Cherry";

        // Use Arrays.stream() to check if the element exists
        boolean found = Arrays.stream(fruits).anyMatch(fruit -> fruit.equals(searchElement));

        // Print the result
        if (found) {
            System.out.println(searchElement + " was found in the array.");
        } else {
            System.out.println(searchElement + " was not found in the array.");
        }
    }
}

Schauen wir uns die Änderungen an:

• import java.util.Arrays;: Wir müssen die Arrays-Klasse importieren, um ihre stream()-Methode verwenden zu können.
• boolean found = Arrays.stream(fruits).anyMatch(fruit -> fruit.equals(searchElement));: Dies ist der Kern des neuen Ansatzes.
  • Arrays.stream(fruits): Dies wandelt das fruits-Array in einen Stream um. Ein Stream ist eine Sequenz von Elementen, die verschiedene Operationen unterstützt.
  • .anyMatch(fruit -> fruit.equals(searchElement)): Dies ist eine Stream-Operation. anyMatch() prüft, ob irgendein Element im Stream die gegebene Bedingung erfüllt. Die Bedingung wird als Lambda-Ausdruck fruit -> fruit.equals(searchElement) angegeben. Dieser Lambda-Ausdruck nimmt jedes fruit aus dem Stream und prüft, ob es gleich dem searchElement ist. Wenn eine Übereinstimmung gefunden wird, gibt anyMatch() sofort true zurück.

Dieser auf Streams basierende Ansatz erreicht dasselbe Ergebnis wie die for-Schleife, jedoch in einem deklarativeren Stil – Sie beschreiben was Sie tun möchten (prüfen, ob irgendein Element die Bedingung erfüllt), statt wie Sie es tun sollen (schrittweise iterieren).

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

Jetzt kompilieren und führen Sie das geänderte Programm im Terminal aus dem ~/project-Verzeichnis aus:

Kompilieren Sie den Code:

javac ArraySearch.java

Führen Sie den kompilierten Code aus:

java ArraySearch

Sie sollten die gleiche Ausgabe wie zuvor sehen:

Cherry was found in the array.

Fühlen Sie sich wieder frei, das searchElement zu ändern, um den else-Fall zu testen.

Umgang mit Null-Elementen

In diesem Schritt betrachten wir ein häufiges Szenario in Java: das Umgang mit null-Werten in Arrays. Wenn ein Array null-Elemente enthält, können unsere bisherigen Methoden Probleme auftreten. Wir werden lernen, wie man null-Werte sicher behandelt, wenn man nach einem Element sucht.

Öffnen Sie erneut die Datei ~/project/ArraySearch.java im WebIDE-Editor.

Ändern Sie das fruits-Array, um ein null-Element einzuschließen:

import java.util.Arrays;
import java.util.Objects; // Import the Objects class

public class ArraySearch {

    public static void main(String[] args) {
        // Define an array of strings with a null element
        String[] fruits = {"Apple", null, "Banana", "Cherry", "Date", "Elderberry"};

        // The element we want to search for
        String searchElement = "Cherry";

        // Use Arrays.stream() and handle nulls
        boolean found = Arrays.stream(fruits)
                              .anyMatch(fruit -> Objects.equals(fruit, searchElement)); // Use Objects.equals

        // Print the result
        if (found) {
            System.out.println(searchElement + " was found in the array.");
        } else {
            System.out.println(searchElement + " was not found in the array.");
        }

        // Let's also search for null itself
        String searchNullElement = null;
        boolean foundNull = Arrays.stream(fruits)
                                  .anyMatch(fruit -> Objects.equals(fruit, searchNullElement));

        if (foundNull) {
            System.out.println("null was found in the array.");
        } else {
            System.out.println("null was not found in the array.");
        }
    }
}

Hier sind die Änderungen, die wir vorgenommen haben:

• import java.util.Objects;: Wir importieren die Objects-Klasse, die Hilfsmethoden für Objekte bereitstellt, einschließlich eines sicheren Umgangs mit null.
• String[] fruits = {"Apple", null, "Banana", "Cherry", "Date", "Elderberry"};: Wir haben null als zweites Element in das fruits-Array eingefügt.
• .anyMatch(fruit -> Objects.equals(fruit, searchElement)): Anstelle von fruit.equals(searchElement) verwenden wir jetzt Objects.equals(fruit, searchElement). Die Objects.equals()-Methode ist so konzipiert, dass sie null-Werte elegant behandelt. Sie gibt true zurück, wenn beide Argumente null sind, und vermeidet es, eine NullPointerException zu werfen, wenn das erste Argument (in diesem Fall fruit) null ist.
• Wir haben eine zweite Suche hinzugefügt, um zu zeigen, wie man null selbst im Array mithilfe der gleichen Objects.equals()-Methode findet.

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

Kompilieren und führen Sie das geänderte Programm im Terminal aus dem ~/project-Verzeichnis aus:

Kompilieren Sie den Code:

javac ArraySearch.java

Führen Sie den kompilierten Code aus:

java ArraySearch

Sie sollten die folgende Ausgabe sehen, die zeigt, dass sowohl "Cherry" als auch null gefunden wurden:

Cherry was found in the array.
null was found in the array.

Die Verwendung von Objects.equals() ist die empfohlene Methode, um Objekte zu vergleichen, insbesondere wenn eines oder beide Objekte möglicherweise null sind. Dies verhindert unerwartete NullPointerException-Fehler.

Zusammenfassung

In diesem Lab haben Sie eine grundlegende Methode kennengelernt, um zu prüfen, ob ein bestimmtes Element in einem Java-Array vorhanden ist: das Iterieren durch das Array mithilfe einer traditionellen for-Schleife. Sie haben gelernt, wie man eine Java-Datei erstellt, ein Array und ein Such-Element definiert, die Schleife implementiert, um die Elemente zu vergleichen, und ein boolesches Flag verwendet, um zu verfolgen, ob das Element gefunden wurde. Diese praktische Übung hat gezeigt, wie man eine grundlegende Suchoperation durchführt und das Ergebnis ausgibt, je nachdem, ob das Element im Array vorhanden war.