Apprendre Organisation des éléments avec la méthode sorted()

Glissez pour afficher le menu

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

Imaginez une usine avec différentes pièces, chacune ayant un poids unique. L'objectif est de trier ces pièces par ordre croissant en fonction de leur poids à l'aide de 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, vous pouvez spécifier un ordre de tri personnalisé, offrant ainsi plus de contrôle sur la façon dont les éléments sont organisés.

Exemple pratique

Supposons que vous deviez trier une liste d'employés d'usine par salaire dans l'ordre décroissant. Vous utiliserez la méthode sorted() 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, vous avez utilisé le comparateur Comparator.comparingInt(Employee::getSalary).reversed(), qui trie d'abord les employés par salaire en ordre croissant, puis applique reversed() pour passer en ordre décroissant.

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 20

Demandez à l'IA

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

Section 1. Chapitre 20