Lære Sortering av elementer med sorted()-metoden

Sveip for å vise menyen

I Javas Stream API gjør sorted()-metoden det mulig å sortere elementer i en strøm på en effektiv måte. Sortering er en viktig operasjon fordi det forenkler databehandling og gjør det lettere å ordne elementene i ønsket rekkefølge.

Naturlig sorteringsrekkefølge

Metoden sorted() er overbelastet og har to versjoner. La oss starte med den første:

Stream<T> sorted();

Denne versjonen sorterer elementer basert på deres naturlige rekkefølge. For å bruke denne metoden må elementene implementere Comparable-grensesnittet, som gjør det mulig å automatisk sammenligne og ordne dem.

Praktisk eksempel

Tenk deg en fabrikk med ulike deler, hvor hver del har en unik vekt. Målet er å sortere disse delene i stigende rekkefølge basert på vekten ved å bruke Comparable-grensesnittet.

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

Her implementerer Part klassen Comparable<Part> grensesnittet. compareTo() metoden sorterer deler etter weight ved å bruke Integer.compare(this.weight, other.weight).

I hovedklassen sorterer sorted() metoden strømmen av deler i stigende rekkefølge basert på deres weight.

Sortering med en Comparator

Den andre versjonen av sorted() metoden tillater sortering ved bruk av en egendefinert Comparator. Denne metoden tar en Comparator som parameter, som definerer hvordan elementene skal sammenlignes og ordnes.

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

Med denne tilnærmingen kan du angi en egendefinert sorteringsrekkefølge, noe som gir oss mer kontroll over hvordan elementene blir ordnet.

Praktisk eksempel

Anta at du må sortere en liste over fabrikkarbeidere etter lønn i synkende rekkefølge. Du bruker sorted()-metoden med en komparator for å oppnå dette.

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

Her brukte du komparatoren Comparator.comparingInt(Employee::getSalary).reversed(), som først sorterer ansatte etter lønn i stigende rekkefølge, og deretter bruker reversed() for å endre til synkende rekkefølge.

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 1. Kapittel 20

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Seksjon 1. Kapittel 20