Apprendre Organisation des Éléments avec la Méthode sorted() | Opérations Intermédiaires dans l'API Stream

Dans l'API Stream de Java, la méthode sorted() permet de trier efficacement les éléments d'un flux. Le tri est une opération essentielle car il simplifie le traitement des données, facilitant ainsi l'organisation des éléments dans l'ordre souhaité.

Tri selon l'ordre naturel

La méthode sorted() est surchargée et possède deux versions. Commençons par la première :

Stream<T> sorted();

Cette version trie les éléments selon leur ordre naturel. Pour utiliser cette méthode, les éléments doivent implémenter l’interface Comparable, ce qui leur permet d’être automatiquement comparés et ordonnés.

Exemple pratique

Considérer une usine avec différentes pièces, chacune ayant un poids unique. L’objectif est de trier ces pièces par ordre croissant selon leur poids en utilisant l’interface 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";
    }
}

Ici, la classe Part implémente l'interface Comparable<Part>. La méthode compareTo() trie les pièces par weight en utilisant Integer.compare(this.weight, other.weight).

Dans la classe principale, la méthode sorted() trie le flux de pièces par ordre croissant selon leur weight.

Tri avec un Comparator

La deuxième version de la méthode sorted() permet le tri à l'aide d'un Comparator personnalisé. Cette méthode prend un Comparator en paramètre, définissant la manière dont les éléments doivent être comparés et ordonnés.

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

Avec cette approche, il est possible de spécifier un ordre de tri personnalisé, offrant ainsi un meilleur contrôle sur la manière dont les éléments sont organisés.

Exemple pratique

Supposons qu'il soit nécessaire de trier une liste d'employés d'usine par salaire dans l'ordre décroissant. La méthode sorted() sera utilisée avec un comparateur pour atteindre cet objectif.

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

Ici, le comparateur Comparator.comparingInt(Employee::getSalary).reversed() a été utilisé, qui classe d'abord les employés par salaire par ordre croissant, puis applique reversed() pour passer à l'ordre décroissant.

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 5

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Awesome!

Completion rate improved to 2.33

Glissez pour afficher le menu

Tri selon l'ordre naturel

La méthode sorted() est surchargée et possède deux versions. Commençons par la première :

Stream<T> sorted();

Exemple pratique

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

Ici, la classe Part implémente l'interface Comparable<Part>. La méthode compareTo() trie les pièces par weight en utilisant Integer.compare(this.weight, other.weight).

Dans la classe principale, la méthode sorted() trie le flux de pièces par ordre croissant selon leur weight.

Tri avec un Comparator

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

Avec cette approche, il est possible de spécifier un ordre de tri personnalisé, offrant ainsi un meilleur contrôle sur la manière dont les éléments sont organisés.

Exemple pratique

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

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 5