Oppiskele Alkioiden Järjestäminen Sorted()-Menetelmällä | Välimuotoiset Operaatiot Stream API:ssa

Java Stream API:n sorted()-metodi mahdollistaa virran alkioiden lajittelun tehokkaasti. Lajittelu on keskeinen operaatio, koska se yksinkertaistaa datan käsittelyä ja helpottaa alkioiden järjestämistä haluttuun järjestykseen.

Luonnollinen järjestyslajittelu

sorted()-metodi on ylikuormitettu ja sillä on kaksi versiota. Aloitetaan ensimmäisestä:

Stream<T> sorted();

Tämä versio järjestää alkiot niiden luonnollisen järjestyksen perusteella. Tämän menetelmän käyttämiseksi alkioiden on toteutettava Comparable-rajapinta, mikä mahdollistaa niiden automaattisen vertailun ja järjestämisen.

Käytännön esimerkki

Kuvitellaan tehdas, jossa on erilaisia osia, joilla jokaisella on yksilöllinen paino. Tavoitteena on järjestää nämä osat nousevaan järjestykseen painon perusteella käyttämällä Comparable-rajapintaa.

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

Tässä Part luokka toteuttaa Comparable<Part> rajapinnan. compareTo() metodi järjestää osat weight-kentän perusteella käyttäen Integer.compare(this.weight, other.weight).

Pääluokassa sorted() metodi järjestää osien virran nousevaan järjestykseen niiden weight-arvon perusteella.

Järjestäminen Comparatorin avulla

sorted() metodin toinen versio mahdollistaa järjestämisen mukautetulla Comparator. Tämä metodi ottaa Comparator parametrina, joka määrittelee, miten alkiot vertaillaan ja järjestetään.

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

Tällä lähestymistavalla voidaan määrittää räätälöity lajittelujärjestys, mikä antaa enemmän hallintaa siihen, miten alkiot järjestetään.

Käytännön esimerkki

Oletetaan, että täytyy lajitella tehtaan työntekijöiden lista palkan mukaan laskevaan järjestykseen. Tätä varten käytetään sorted()-metodia yhdessä vertailijan kanssa.

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

Tässä käytettiin vertailijaa Comparator.comparingInt(Employee::getSalary).reversed(), joka ensin järjestää työntekijät palkan mukaan nousevaan järjestykseen ja käyttää sitten reversed()-metodia vaihtaakseen järjestyksen laskevaan.

Oliko kaikki selvää?

Kiitos palautteestasi!

Osio 2. Luku 5

Kysy tekoälyä

Kysy mitä tahansa tai kokeile jotakin ehdotetuista kysymyksistä aloittaaksesi keskustelumme

Awesome!

Completion rate improved to 2.33

Pyyhkäise näyttääksesi valikon

Luonnollinen järjestyslajittelu

sorted()-metodi on ylikuormitettu ja sillä on kaksi versiota. Aloitetaan ensimmäisestä:

Stream<T> sorted();

Käytännön esimerkki

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

Tässä Part luokka toteuttaa Comparable<Part> rajapinnan. compareTo() metodi järjestää osat weight-kentän perusteella käyttäen Integer.compare(this.weight, other.weight).

Pääluokassa sorted() metodi järjestää osien virran nousevaan järjestykseen niiden weight-arvon perusteella.

Järjestäminen Comparatorin avulla

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

Tällä lähestymistavalla voidaan määrittää räätälöity lajittelujärjestys, mikä antaa enemmän hallintaa siihen, miten alkiot järjestetään.

Käytännön esimerkki

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

Oliko kaikki selvää?

Kiitos palautteestasi!

Osio 2. Luku 5