Impara Ordinamento degli Elementi con il Metodo sorted() | Operazioni Intermedie Nello Stream API

Nell'API Stream di Java, il metodo sorted() consente di ordinare in modo efficiente gli elementi di uno stream. L'ordinamento è un'operazione fondamentale perché semplifica l'elaborazione dei dati, facilitando la disposizione degli elementi nell'ordine desiderato.

Ordinamento in ordine naturale

Il metodo sorted() è sovraccaricato e presenta due versioni. Iniziamo con la prima:

Stream<T> sorted();

Questa versione ordina gli elementi in base al loro ordinamento naturale. Per utilizzare questo metodo, gli elementi devono implementare l'interfaccia Comparable, che consente loro di essere automaticamente confrontati e ordinati.

Esempio pratico

Immagina una fabbrica con diversi pezzi, ognuno con un peso unico. L'obiettivo è ordinare questi pezzi in ordine crescente in base al loro peso utilizzando l'interfaccia Comparable.

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

Qui, la classe Part implementa l'interfaccia Comparable<Part>. Il metodo compareTo() ordina le parti per weight utilizzando Integer.compare(this.weight, other.weight).

Nella classe principale, il metodo sorted() ordina lo stream di parti in ordine crescente in base al loro weight.

Ordinamento con un Comparator

La seconda versione del metodo sorted() consente l'ordinamento utilizzando un Comparator personalizzato. Questo metodo accetta un Comparator come parametro, definendo come gli elementi devono essere confrontati e ordinati.

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

Con questo approccio, è possibile specificare un ordine di ordinamento personalizzato, offrendo un maggiore controllo su come gli elementi vengono disposti.

Esempio pratico

Supponiamo sia necessario ordinare un elenco di dipendenti di fabbrica in base allo stipendio in ordine decrescente. Verrà utilizzato il metodo sorted() con un comparator per ottenere questo risultato.

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

Qui è stato utilizzato il comparator Comparator.comparingInt(Employee::getSalary).reversed(), che inizialmente ordina i dipendenti per stipendio in ordine crescente e poi applica reversed() per passare all'ordine decrescente.

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 2. Capitolo 5

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Awesome!

Completion rate improved to 2.33

Scorri per mostrare il menu

Ordinamento in ordine naturale

Il metodo sorted() è sovraccaricato e presenta due versioni. Iniziamo con la prima:

Stream<T> sorted();

Esempio pratico

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

Qui, la classe Part implementa l'interfaccia Comparable<Part>. Il metodo compareTo() ordina le parti per weight utilizzando Integer.compare(this.weight, other.weight).

Nella classe principale, il metodo sorted() ordina lo stream di parti in ordine crescente in base al loro weight.

Ordinamento con un Comparator

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

Con questo approccio, è possibile specificare un ordine di ordinamento personalizzato, offrendo un maggiore controllo su come gli elementi vengono disposti.

Esempio pratico

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

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 2. Capitolo 5