Leer Items Ordenen met de sorted()-Methode | Intermediaire Bewerkingen in Stream API

In Java's Stream API maakt de methode sorted() het mogelijk om stream-elementen efficiënt te sorteren. Sorteren is een essentiële bewerking omdat het gegevensverwerking vereenvoudigt, waardoor het gemakkelijker wordt om elementen in de gewenste volgorde te rangschikken.

Sorteren op natuurlijke volgorde

De methode sorted() is overbelast en heeft twee versies. Laten we beginnen met de eerste:

Stream<T> sorted();

Deze versie sorteert elementen op basis van hun natuurlijke volgorde. Om deze methode te gebruiken, moeten de elementen de Comparable interface implementeren, waardoor ze automatisch kunnen worden vergeleken en geordend.

Praktisch Voorbeeld

Stel je een fabriek voor met verschillende onderdelen, elk met een uniek gewicht. Het doel is om deze onderdelen in oplopende volgorde te sorteren op basis van hun gewicht met behulp van de Comparable interface.

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 implementeert de Part klasse de Comparable<Part> interface. De compareTo() methode sorteert onderdelen op weight met behulp van Integer.compare(this.weight, other.weight).

In de hoofdklasse sorteert de sorted() methode de stream van onderdelen in oplopende volgorde op basis van hun weight.

Sorteren met een Comparator

De tweede versie van de sorted() methode maakt sorteren mogelijk met een aangepaste Comparator. Deze methode neemt een Comparator als parameter, waarmee wordt bepaald hoe elementen moeten worden vergeleken en geordend.

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

Met deze benadering kun je een aangepaste sorteervolgorde specificeren, waardoor er meer controle is over hoe elementen worden gerangschikt.

Praktisch Voorbeeld

Stel dat je een lijst van fabrieksmedewerkers moet sorteren op salaris in aflopende volgorde. Hiervoor gebruik je de sorted() methode met een comparator.

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 is de comparator Comparator.comparingInt(Employee::getSalary).reversed() gebruikt, die eerst werknemers op salaris in oplopende volgorde sorteert en vervolgens met reversed() omzet naar aflopende volgorde.

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 2. Hoofdstuk 5

Vraag AI

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Suggested prompts:

Can you show an example of sorting a custom class using the natural order?

How do I implement the Comparable interface in my own class?

Can you explain how to use a custom Comparator with the sorted() method?

Awesome!

Completion rate improved to 2.33

Veeg om het menu te tonen

Sorteren op natuurlijke volgorde

De methode sorted() is overbelast en heeft twee versies. Laten we beginnen met de eerste:

Stream<T> sorted();

Praktisch Voorbeeld

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 implementeert de Part klasse de Comparable<Part> interface. De compareTo() methode sorteert onderdelen op weight met behulp van Integer.compare(this.weight, other.weight).

In de hoofdklasse sorteert de sorted() methode de stream van onderdelen in oplopende volgorde op basis van hun weight.

Sorteren met een Comparator

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

Met deze benadering kun je een aangepaste sorteervolgorde specificeren, waardoor er meer controle is over hoe elementen worden gerangschikt.

Praktisch Voorbeeld

Stel dat je een lijst van fabrieksmedewerkers moet sorteren op salaris in aflopende volgorde. Hiervoor gebruik je de sorted() methode met een comparator.

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;
    }
}

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 2. Hoofdstuk 5