Wie man prüft, ob eine Liste in Java sortiert ist

JavaJavaBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab lernen Sie, wie Sie in Java prüfen können, ob eine Liste sortiert ist. Wir werden verschiedene Ansätze untersuchen, um diese Aufgabe zu erfüllen, beginnend mit einer grundlegenden Methode, bei der benachbarte Elemente in der Liste verglichen werden.

Sie werden dann entdecken, wie Sie die Macht der Java Stream API nutzen können, um die Sortierprüfung auf eine kompaktere und möglicherweise effizientere Weise durchzuführen. Abschließend werden wir darauf eingehen, wie Sie verschiedene Sortierreihenfolgen, wie aufsteigend und absteigend, behandeln können, um Ihre Sortierprüfungen flexibler zu gestalten.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java(("Java")) -.-> java/DataStructuresGroup(["Data Structures"]) java(("Java")) -.-> java/ObjectOrientedandAdvancedConceptsGroup(["Object-Oriented and Advanced Concepts"]) java(("Java")) -.-> java/FileandIOManagementGroup(["File and I/O Management"]) java/BasicSyntaxGroup -.-> java/for_loop("For Loop") java/DataStructuresGroup -.-> java/arrays("Arrays") java/DataStructuresGroup -.-> java/sorting("Sorting") java/DataStructuresGroup -.-> java/collections_methods("Collections Methods") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/arraylist("ArrayList") java/FileandIOManagementGroup -.-> java/stream("Stream") subgraph Lab Skills java/for_loop -.-> lab-559950{{"Wie man prüft, ob eine Liste in Java sortiert ist"}} java/arrays -.-> lab-559950{{"Wie man prüft, ob eine Liste in Java sortiert ist"}} java/sorting -.-> lab-559950{{"Wie man prüft, ob eine Liste in Java sortiert ist"}} java/collections_methods -.-> lab-559950{{"Wie man prüft, ob eine Liste in Java sortiert ist"}} java/arraylist -.-> lab-559950{{"Wie man prüft, ob eine Liste in Java sortiert ist"}} java/stream -.-> lab-559950{{"Wie man prüft, ob eine Liste in Java sortiert ist"}} end

Vergleich benachbarter Listenelemente

In diesem Schritt lernen wir, wie man benachbarte Elemente in einer Liste (genauer gesagt, in einer List in Java) vergleicht. Dies ist eine häufige Aufgabe, wenn man Muster oder Reihenfolgen in einer Datenfolge prüfen muss. Wir beginnen damit, ein einfaches Java-Programm zu erstellen, das eine Schleife verwendet, um durch eine Liste zu iterieren und jedes Element mit dem unmittelbar darauffolgenden Element zu vergleichen.

Zunächst erstellen wir eine neue Java-Datei namens ListComparison.java in Ihrem ~/project-Verzeichnis. Sie können dies über den Dateiexplorer der WebIDE auf der linken Seite tun. Klicken Sie mit der rechten Maustaste im ~/project-Bereich, wählen Sie "Neue Datei" und geben Sie ListComparison.java ein.

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

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

public class ListComparison {

    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(3);
        numbers.add(2);
        numbers.add(4);
        numbers.add(5);

        System.out.println("Original list: " + numbers);

        // Loop through the list, comparing adjacent elements
        for (int i = 0; i < numbers.size() - 1; i++) {
            Integer currentElement = numbers.get(i);
            Integer nextElement = numbers.get(i + 1);

            System.out.println("Comparing " + currentElement + " and " + nextElement);

            if (currentElement < nextElement) {
                System.out.println(currentElement + " is less than " + nextElement);
            } else if (currentElement > nextElement) {
                System.out.println(currentElement + " is greater than " + nextElement);
            } else {
                System.out.println(currentElement + " is equal to " + nextElement);
            }
        }
    }
}

Lassen Sie uns diesen Code analysieren:

  • import java.util.ArrayList; und import java.util.List;: Diese Zeilen importieren die notwendigen Klassen, um mit Listen in Java zu arbeiten.
  • List<Integer> numbers = new ArrayList<>();: Dies erstellt eine neue Liste namens numbers, die Integer-Objekte (ganze Zahlen) enthalten kann.
  • numbers.add(...): Diese Zeilen fügen Elemente zu unserer Liste hinzu.
  • for (int i = 0; i < numbers.size() - 1; i++): Dies ist eine for-Schleife, die durch die Liste iteriert. Beachten Sie, dass die Schleifenbedingung i < numbers.size() - 1 lautet. Dies ist wichtig, da wir numbers.get(i) mit numbers.get(i + 1) vergleichen. Wenn wir bis numbers.size() iterieren würden, würde i + 1 bei der letzten Iteration außerhalb der Liste liegen.
  • Integer currentElement = numbers.get(i);: Dies ruft das Element am aktuellen Index i ab.
  • Integer nextElement = numbers.get(i + 1);: Dies ruft das Element am nächsten Index i + 1 ab.
  • System.out.println(...): Diese Zeilen geben Informationen auf der Konsole aus, die anzeigen, welche Elemente verglichen werden und das Ergebnis des Vergleichs.
  • if, else if, else: Dies sind bedingte Anweisungen, die prüfen, ob das currentElement kleiner, größer oder gleich dem nextElement ist.

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

Jetzt kompilieren und führen wir das Programm aus. Öffnen Sie das Terminal unten in der WebIDE. Stellen Sie sicher, dass Sie sich im ~/project-Verzeichnis befinden (Sie können cd ~/project verwenden, wenn erforderlich).

Kompilieren Sie den Code mit javac:

javac ListComparison.java

Wenn keine Fehler auftreten, wird eine ListComparison.class-Datei erstellt. Führen Sie nun den kompilierten Code mit java aus:

java ListComparison

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Original list: [1, 3, 2, 4, 5]
Comparing 1 and 3
1 is less than 3
Comparing 3 and 2
3 is greater than 2
Comparing 2 and 4
2 is less than 4
Comparing 4 and 5
4 is less than 5

Diese Ausgabe zeigt, dass unser Programm erfolgreich durch die Liste iteriert und jedes benachbarte Elementpaar verglichen hat, wobei das Ergebnis jedes Vergleichs ausgegeben wurde.

Verwendung der Stream API zur Sortierprüfung

In diesem Schritt werden wir einen moderneren und oft kompakteren Weg erkunden, um zu prüfen, ob eine Liste sortiert ist, indem wir die Stream API von Java nutzen. Die Stream API, die in Java 8 eingeführt wurde, bietet einen funktionalen Ansatz zur Verarbeitung von Datenkollektionen.

Wir werden unser vorheriges Programm erweitern, um eine Methode hinzuzufügen, die prüft, ob die Liste in aufsteigender Reihenfolge sortiert ist, indem sie Streams verwendet.

Öffnen Sie die Datei ListComparison.java im Editor der WebIDE. Fügen Sie der ListComparison-Klasse eine neue Methode namens isSortedAscending hinzu, außerhalb der main-Methode, aber innerhalb der geschweiften Klammern {} der ListComparison-Klasse.

Hier ist der aktualisierte Code für ListComparison.java:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;

public class ListComparison {

    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(3);
        numbers.add(2);
        numbers.add(4);
        numbers.add(5);

        System.out.println("Original list: " + numbers);

        // Check if the list is sorted using the new method
        boolean sorted = isSortedAscending(numbers);

        if (sorted) {
            System.out.println("The list is sorted in ascending order.");
        } else {
            System.out.println("The list is NOT sorted in ascending order.");
        }

        // The previous loop for comparison is removed for simplicity in this step
        // but you can keep it if you want to see both methods in action.
    }

    // Method to check if the list is sorted in ascending order using Streams
    public static boolean isSortedAscending(List<Integer> list) {
        if (list == null || list.size() <= 1) {
            return true; // An empty or single-element list is considered sorted
        }

        return IntStream.range(0, list.size() - 1)
                .allMatch(i -> list.get(i).compareTo(list.get(i + 1)) <= 0);
    }
}

Schauen wir uns die neuen Teile an:

  • import java.util.stream.IntStream;: Dies importiert die IntStream-Klasse, die nützlich ist, um mit Sequenzen von Ganzzahlen in Streams zu arbeiten.
  • public static boolean isSortedAscending(List<Integer> list): Dies deklariert eine neue statische Methode namens isSortedAscending, die eine List von Integer entgegennimmt und einen boolean zurückgibt (true, wenn sortiert, false sonst).
  • if (list == null || list.size() <= 1): Dies behandelt Randfälle: Eine leere Liste oder eine Liste mit einem Element wird immer als sortiert betrachtet.
  • IntStream.range(0, list.size() - 1): Dies erstellt einen Stream von Ganzzahlen von 0 bis (aber nicht einschließlich) list.size() - 1. Diese Ganzzahlen repräsentieren die Indizes der Listenelemente, die wir vergleichen möchten.
  • .allMatch(i -> list.get(i).compareTo(list.get(i + 1)) <= 0): Dies ist der Kern der Stream-Operation.
    • allMatch() ist eine Terminal-Operation, die prüft, ob alle Elemente im Stream einer gegebenen Bedingung entsprechen.
    • i -> list.get(i).compareTo(list.get(i + 1)) <= 0 ist ein Lambda-Ausdruck, der die Bedingung definiert. Für jeden Index i aus dem IntStream wird das Element am Index i und das Element am Index i + 1 abgerufen.
    • list.get(i).compareTo(list.get(i + 1)) vergleicht die beiden Elemente. compareTo gibt eine negative Ganzzahl zurück, wenn das erste Element kleiner als das zweite ist, null, wenn sie gleich sind, und eine positive Ganzzahl, wenn das erste Element größer als das zweite ist.
    • <= 0 prüft, ob das Ergebnis von compareTo kleiner oder gleich null ist. Diese Bedingung ist wahr, wenn das aktuelle Element kleiner oder gleich dem nächsten Element ist, was die Definition der aufsteigenden Reihenfolge ist.
    • allMatch gibt nur dann true zurück, wenn diese Bedingung für alle benachbarten Elementpaare in der Liste wahr ist.

Speichern Sie die Datei ListComparison.java.

Jetzt kompilieren und führen Sie das aktualisierte Programm im Terminal aus:

javac ListComparison.java
java ListComparison

Die Ausgabe sollte nun anzeigen, ob die Liste in aufsteigender Reihenfolge sortiert ist, basierend auf der isSortedAscending-Methode:

Original list: [1, 3, 2, 4, 5]
The list is NOT sorted in ascending order.

Ändern Sie die Liste in der main-Methode so, dass sie sortiert ist, beispielsweise:

        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);

Speichern Sie die Datei, kompilieren und führen Sie es erneut aus. Die Ausgabe sollte nun lauten:

Original list: [1, 2, 3, 4, 5]
The list is sorted in ascending order.

Dies zeigt, wie man die Stream API verwendet, um eine kompakte Prüfung auf aufsteigende Reihenfolge durchzuführen.

Umgang mit verschiedenen Sortierreihenfolgen

Im vorherigen Schritt haben wir eine Methode erstellt, um zu prüfen, ob eine Liste in aufsteigender Reihenfolge sortiert ist. In diesem Schritt erweitern wir unser Programm, um verschiedene Sortierreihenfolgen zu verarbeiten: aufsteigend und absteigend. Wir werden eine neue Methode hinzufügen, die die Liste und die gewünschte Sortierreihenfolge als Eingabe nimmt.

Öffnen Sie die Datei ListComparison.java im Editor der WebIDE. Wir werden eine neue Methode namens isSorted hinzufügen, die die Liste und einen boolean-Wert entgegennimmt, der angibt, ob wir auf aufsteigende Reihenfolge (true) oder absteigende Reihenfolge (false) prüfen möchten.

Hier ist der aktualisierte Code für ListComparison.java:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;

public class ListComparison {

    public static void main(String[] args) {
        List<Integer> numbersAsc = new ArrayList<>();
        numbersAsc.add(1);
        numbersAsc.add(2);
        numbersAsc.add(3);
        numbersAsc.add(4);
        numbersAsc.add(5);

        List<Integer> numbersDesc = new ArrayList<>();
        numbersDesc.add(5);
        numbersDesc.add(4);
        numbersDesc.add(3);
        numbersDesc.add(2);
        numbersDesc.add(1);

        List<Integer> numbersUnsorted = new ArrayList<>();
        numbersUnsorted.add(1);
        numbersUnsorted.add(3);
        numbersUnsorted.add(2);
        numbersUnsorted.add(4);
        numbersUnsorted.add(5);


        System.out.println("Checking list: " + numbersAsc);
        System.out.println("Is ascending sorted? " + isSorted(numbersAsc, true));
        System.out.println("Is descending sorted? " + isSorted(numbersAsc, false));
        System.out.println();

        System.out.println("Checking list: " + numbersDesc);
        System.out.println("Is ascending sorted? " + isSorted(numbersDesc, true));
        System.out.println("Is descending sorted? " + isSorted(numbersDesc, false));
        System.out.println();

        System.out.println("Checking list: " + numbersUnsorted);
        System.out.println("Is ascending sorted? " + isSorted(numbersUnsorted, true));
        System.out.println("Is descending sorted? " + isSorted(numbersUnsorted, false));
        System.out.println();

    }

    // Method to check if the list is sorted based on the specified order
    public static boolean isSorted(List<Integer> list, boolean ascending) {
        if (list == null || list.size() <= 1) {
            return true; // An empty or single-element list is considered sorted
        }

        return IntStream.range(0, list.size() - 1)
                .allMatch(i -> {
                    int comparison = list.get(i).compareTo(list.get(i + 1));
                    if (ascending) {
                        return comparison <= 0; // For ascending, current must be <= next
                    } else {
                        return comparison >= 0; // For descending, current must be >= next
                    }
                });
    }
}

Schauen wir uns die Änderungen an:

  • Wir haben in der main-Methode drei verschiedene Listen erstellt: numbersAsc (aufsteigend sortiert), numbersDesc (absteigend sortiert) und numbersUnsorted.
  • Wir rufen die neue isSorted-Methode für jede Liste auf, sowohl mit true (für aufsteigend) als auch mit false (für absteigend) als Wert für den ascending-Parameter.
  • public static boolean isSorted(List<Integer> list, boolean ascending): Dies ist die Signatur unserer neuen Methode, die die Liste und ein boolesches Flag für die Reihenfolge akzeptiert.
  • Innerhalb des allMatch-Lambda-Ausdrucks:
    • int comparison = list.get(i).compareTo(list.get(i + 1));: Wir vergleichen benachbarte Elemente.
    • if (ascending): Wenn das ascending-Flag true ist, prüfen wir, ob comparison <= 0 (das aktuelle Element ist kleiner oder gleich dem nächsten).
    • else: Wenn das ascending-Flag false ist (das heißt, wir prüfen auf absteigende Reihenfolge), prüfen wir, ob comparison >= 0 (das aktuelle Element ist größer oder gleich dem nächsten).

Speichern Sie die Datei ListComparison.java.

Jetzt kompilieren und führen Sie das aktualisierte Programm im Terminal aus:

javac ListComparison.java
java ListComparison

Die Ausgabe sollte die Ergebnisse der Prüfung jeder Liste auf sowohl aufsteigende als auch absteigende Reihenfolge anzeigen:

Checking list: [1, 2, 3, 4, 5]
Is ascending sorted? true
Is descending sorted? false

Checking list: [5, 4, 3, 2, 1]
Is ascending sorted? false
Is descending sorted? true

Checking list: [1, 3, 2, 4, 5]
Is ascending sorted? false
Is descending sorted? false

Dies zeigt, wie man eine flexible Methode mit der Stream API erstellt, um verschiedene Sortierreihenfolgen zu prüfen, indem man die Vergleichslogik basierend auf einem Eingabeparameter anpasst.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java prüft, ob eine Liste sortiert ist, indem man verschiedene Ansätze verfolgt. Wir begannen damit, eine Methode zu implementieren, die benachbarte Elemente in einer Liste mithilfe einer herkömmlichen Schleife vergleicht. Dies vermittelt ein grundlegendes Verständnis der Logik zur Prüfung der Sortierung. Dabei wurde die Liste durchlaufen und jedes Element mit seinem Nachfolger verglichen, um ungeordnete Paare zu identifizieren.

Anschließend haben wir untersucht, wie man die Java Stream API nutzen kann, um auf eine kompaktere und funktionalere Weise die Sortierung einer Liste zu prüfen. Diese Methode nutzt Stream-Operationen, um effizient zu bestimmen, ob die Elemente in der gewünschten Reihenfolge sind. Schließlich haben wir uns damit befasst, wie man verschiedene Sortierreihenfolgen (aufsteigend und absteigend) bei der Sortierungsprüfung behandelt. Dies zeigt, wie man die Vergleichslogik an verschiedene Sortierungsanforderungen anpassen kann.