Lernen Anordnung von Elementen in Reihenfolge mit der Methode Sorted()

In der Java Stream API ermöglicht die Methode sorted(), Streamelemente effizient zu sortieren. Sortierung ist eine wichtige Operation, da sie die Datenverarbeitung vereinfacht und das Anordnen der Elemente in der gewünschten Reihenfolge erleichtert.

Sortierung in natürlicher Reihenfolge

Die Methode sorted() ist überladen und besitzt zwei Varianten. Beginnen wir mit der ersten:

Stream<T> sorted();

Diese Version sortiert Elemente basierend auf ihrer natürlichen Reihenfolge. Um diese Methode zu verwenden, müssen die Elemente das Comparable-Interface implementieren, das es ihnen ermöglicht, automatisch verglichen und geordnet zu werden.

Praktisches Beispiel

Stellen Sie sich eine Fabrik mit verschiedenen Teilen vor, von denen jedes ein einzigartiges Gewicht hat. Das Ziel ist es, diese Teile mithilfe des Comparable-Interfaces in aufsteigender Reihenfolge nach ihrem Gewicht zu sortieren.

Main.java


              12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849
            
package com.example;

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // List of factory parts
        List<Part> parts = Arrays.asList(
                new Part("Wheel", 10),
                new Part("Engine", 250),
                new Part("Brake", 15),
                new Part("Chassis", 80)
        );

        // Sorting parts by weight in ascending order
        parts.stream()
                .sorted()  // Sorting by natural order
                .forEach(System.out::println);
    }
}

class Part implements Comparable<Part> {
    private String partName;
    private int weight;

    public Part(String partName, int weight) {
        this.partName = partName;
        this.weight = weight;
    }

    public String getPartName() {
        return partName;
    }

    public int getWeight() {
        return weight;
    }

    @Override
    public int compareTo(Part other) {
        return Integer.compare(this.weight, other.weight);  // Sorting by weight
    }

    @Override
    public String toString() {
        return partName + ": " + weight + "kg";
    }
}

Hier implementiert die Klasse Part das Interface Comparable<Part>. Die Methode compareTo() sortiert Teile nach weight mittels Integer.compare(this.weight, other.weight).

In der Hauptklasse sortiert die Methode sorted() den Stream von Teilen in aufsteigender Reihenfolge basierend auf ihrem weight.

Sortieren mit einem Comparator

Die zweite Version der Methode sorted() ermöglicht das Sortieren mit einem benutzerdefinierten Comparator. Diese Methode nimmt einen Comparator als Parameter entgegen, der definiert, wie Elemente verglichen und angeordnet werden sollen.

Stream<T> sorted(Comparator<? super T> comparator);

Mit diesem Ansatz kann eine benutzerdefinierte Sortierreihenfolge festgelegt werden, was mehr Kontrolle darüber bietet, wie Elemente angeordnet werden.

Praktisches Beispiel

Angenommen, eine Liste von Fabrikmitarbeitern soll nach dem Gehalt in absteigender Reihenfolge sortiert werden. Hierfür wird die sorted()-Methode mit einem Comparator verwendet.

Main.java


              123456789101112131415161718192021222324252627282930313233343536373839404142434445
            
package com.example;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // List of factory employees
        List<Employee> employees = Arrays.asList(
                new Employee("John", 50000),
                new Employee("Emily", 75000),
                new Employee("Michael", 45000),
                new Employee("Sophia", 60000)
        );

        // Sorting employees by salary in descending order
        employees.stream()
                .sorted(Comparator.comparingInt(Employee::getSalary).reversed())  // Sorting in descending order
                .forEach(System.out::println);
    }
}

class Employee {
    private String name;
    private int salary;

    public Employee(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public int getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return name + ": " + salary;
    }
}

Hier wurde der Comparator Comparator.comparingInt(Employee::getSalary).reversed() verwendet, der zunächst die Mitarbeiter nach dem Gehalt in aufsteigender Reihenfolge sortiert und anschließend mit reversed() in absteigende Reihenfolge umkehrt.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 5

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen

Awesome!

Completion rate improved to 2.33

Swipe um das Menü anzuzeigen

Sortierung in natürlicher Reihenfolge

Die Methode sorted() ist überladen und besitzt zwei Varianten. Beginnen wir mit der ersten:

Stream<T> sorted();

Praktisches Beispiel

Main.java


              12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849
            
package com.example;

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // List of factory parts
        List<Part> parts = Arrays.asList(
                new Part("Wheel", 10),
                new Part("Engine", 250),
                new Part("Brake", 15),
                new Part("Chassis", 80)
        );

        // Sorting parts by weight in ascending order
        parts.stream()
                .sorted()  // Sorting by natural order
                .forEach(System.out::println);
    }
}

class Part implements Comparable<Part> {
    private String partName;
    private int weight;

    public Part(String partName, int weight) {
        this.partName = partName;
        this.weight = weight;
    }

    public String getPartName() {
        return partName;
    }

    public int getWeight() {
        return weight;
    }

    @Override
    public int compareTo(Part other) {
        return Integer.compare(this.weight, other.weight);  // Sorting by weight
    }

    @Override
    public String toString() {
        return partName + ": " + weight + "kg";
    }
}

Hier implementiert die Klasse Part das Interface Comparable<Part>. Die Methode compareTo() sortiert Teile nach weight mittels Integer.compare(this.weight, other.weight).

In der Hauptklasse sortiert die Methode sorted() den Stream von Teilen in aufsteigender Reihenfolge basierend auf ihrem weight.

Sortieren mit einem Comparator

Stream<T> sorted(Comparator<? super T> comparator);

Mit diesem Ansatz kann eine benutzerdefinierte Sortierreihenfolge festgelegt werden, was mehr Kontrolle darüber bietet, wie Elemente angeordnet werden.

Praktisches Beispiel

Main.java


              123456789101112131415161718192021222324252627282930313233343536373839404142434445
            
package com.example;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // List of factory employees
        List<Employee> employees = Arrays.asList(
                new Employee("John", 50000),
                new Employee("Emily", 75000),
                new Employee("Michael", 45000),
                new Employee("Sophia", 60000)
        );

        // Sorting employees by salary in descending order
        employees.stream()
                .sorted(Comparator.comparingInt(Employee::getSalary).reversed())  // Sorting in descending order
                .forEach(System.out::println);
    }
}

class Employee {
    private String name;
    private int salary;

    public Employee(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public int getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return name + ": " + salary;
    }
}

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 5