Lära Ordna Objekt i Ordning med Metoden Sorted() | Intermediära Operationer i Stream API

I Javas Stream API möjliggör metoden sorted() att sortera element i en stream på ett effektivt sätt. Sortering är en viktig operation eftersom den förenklar databehandling och gör det lättare att ordna element i önskad ordning.

Sortering i naturlig ordning

Metoden sorted() är överlagrad och har två versioner. Låt oss börja med den första:

Stream<T> sorted();

Denna version sorterar element baserat på deras naturliga ordning. För att använda denna metod måste elementen implementera Comparable-gränssnittet, vilket gör det möjligt att automatiskt jämföra och ordna dem.

Praktiskt exempel

Föreställ dig en fabrik med olika delar, där varje del har en unik vikt. Målet är att sortera dessa delar i stigande ordning baserat på deras vikt med hjälp av Comparable-gränssnittet.

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

Här implementerar klassen Part gränssnittet Comparable<Part>. Metoden compareTo() sorterar delar efter weight med hjälp av Integer.compare(this.weight, other.weight).

I huvudklassen sorterar metoden sorted() strömmen av delar i stigande ordning baserat på deras weight.

Sortering med en Comparator

Den andra versionen av metoden sorted() möjliggör sortering med en anpassad Comparator. Denna metod tar en Comparator som parameter, vilket definierar hur element ska jämföras och ordnas.

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

Med denna metod kan du ange en anpassad sorteringsordning, vilket ger oss mer kontroll över hur elementen ordnas.

Praktiskt exempel

Antag att du behöver sortera en lista med fabriksanställda efter lön i fallande ordning. Du använder sorted()-metoden med en komparator för att uppnå detta.

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

Här användes komparatorn Comparator.comparingInt(Employee::getSalary).reversed(), som först sorterar anställda efter lön i stigande ordning och sedan använder reversed() för att ändra till fallande ordning.

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 2. Kapitel 5

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

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

Svep för att visa menyn

Sortering i naturlig ordning

Metoden sorted() är överlagrad och har två versioner. Låt oss börja med den första:

Stream<T> sorted();

Praktiskt exempel

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

Här implementerar klassen Part gränssnittet Comparable<Part>. Metoden compareTo() sorterar delar efter weight med hjälp av Integer.compare(this.weight, other.weight).

I huvudklassen sorterar metoden sorted() strömmen av delar i stigande ordning baserat på deras weight.

Sortering med en Comparator

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

Med denna metod kan du ange en anpassad sorteringsordning, vilket ger oss mer kontroll över hur elementen ordnas.

Praktiskt exempel

Antag att du behöver sortera en lista med fabriksanställda efter lön i fallande ordning. Du använder sorted()-metoden med en komparator för att uppnå detta.

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

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 2. Kapitel 5