Utilisation liée à Java Stream

Le tri Java Stream est un moyen important de trier les éléments d'une collection, et Java Stream lui-même est une méthode élégante et efficace de traitement des collections. Cet article détaillera le tri Java Stream sous de nombreux aspects, notamment les méthodes de tri, le tri personnalisé, le tri des objets, etc.

1. Méthode de tri

Java Stream fournit diverses façons de trier les collections, telles que sorted(), sorted(Comparator), distinct(), etc. Parmi elles, la méthode sorted() est l’une des méthodes de tri les plus couramment utilisées.

La méthode sorted() n'a pas besoin de transmettre de paramètres et triera automatiquement les éléments en utilisant leur ordre naturel. Par exemple, pour trier une collection de type Integer :

//初始列表
List<Integer> list = Arrays.asList(3,2,1,4,5);

//排序后的列表
List<Integer> sortedList = list.stream().sorted().collect(Collectors.toList());

//打印输出排序后的结果 1 2 3 4 5
sortedList.forEach(System.out::print);

La méthode sorted(Comparator) nécessite de transmettre un objet Comparator, qui définit les règles de tri des éléments.

Par exemple, triez par taille d'élément par ordre décroissant :

List<Integer> list = Arrays.asList(3,2,1,4,5);
list.stream().sorted((x, y) -> y - x).forEach(System.out::print); // 5 4 3 2 1

2. Tri personnalisé

Si le type d'élément est une classe personnalisée plutôt qu'un type de base ou un type de chaîne, nous pouvons utiliser la méthode sorted(Comparator) et transmettre un comparateur personnalisé pour le tri. Par exemple, pour une collection d’objets de classe Personne, triés par ordre croissant par âge :

List<Person> personList = Arrays.asList(
    new Person("Jenny", 20),
    new Person("Tom", 19),
    new Person("Mike", 24),
    new Person("Amy", 18)
);


// Person的第一个属性为名称（name）, 第二个属性为年龄（age）

List<Person> sortedList = personList.stream()
.sorted(Comparator.comparing(Person::getAge))
.collect(Collectors.toList());

// 排序结果为： Amy --> Tom --> Jenny --> Mike





3. Tri des attributs uniques des objets

Parfois, nous devons trier une certaine propriété d'un objet plutôt que l'objet entier.

Par exemple, s'il y a plusieurs élèves dans une classe, triez les élèves en fonction de leur numéro d'élève :

List<Student> studentList = Arrays.asList(
    new Student("Tom", 5),
    new Student("Jenny", 1),
    new Student("Mike", 3),
    new Student("Amy", 2)
));

// Student的第一个属性为名称（name）, 第二个属性为学号（number）

List<Student> sortedStudentList = studentList.stream()
.sorted(Comparator.comparing(Student::getNumber))
.collect(Collectors.toList());

// 排序结果为： Jenny --> Amy --> Mike  --> Tom



4. Tri multi-niveaux (tri multi-attributs d'objets)

Parfois, nous devons trier selon plusieurs attributs, par exemple, trier par numéro d'étudiant par ordre croissant. Si le numéro d'étudiant est le même, trier par nom par ordre croissant :

List<Student> studentList = Arrays.asList(
    new Student("Tom", 5),
    new Student("Jenny", 1),
    new Student("Mike", 3),
    new Student("Amy", 2)
));

List<Student> sortedStudents = students.stream().sorted(
Comparator.comparing(Student::getNumber).thenComparing(Student::getName)
).collect(Collectors.toList());

// 排序结果为： Jenny --> Amy --> Mike  --> Tom



5. Disposez dans l’ordre inverse

Si vous devez trier la collection dans l'ordre inverse, vous pouvez utiliser la méthode sorted(Comparator) et transmettre un objet Comparator personnalisé pour obtenir l'ordre inverse. Par exemple, triez la collection d'étudiants initialement classée par ordre croissant par numéro d'étudiant dans l'ordre inverse :

List<Student> studentList = Arrays.asList(
    new Student("Tom", 5),
    new Student("Jenny", 1),
    new Student("Mike", 3),
    new Student("Amy", 2)
));

//按学号对学生进行倒序排序
List<Student> sortedStudents = studentList().stream().sorted(
Comparator.comparing(Student::getNumber).reversed()
).collect(Collectors.toList());

// 排序结果为： Tom --> Mike --> Amy --> Jenny



6. Opération de déduplication

Java Stream fournit la méthode distinct() pour la déduplication. Il renverra une collection dédupliquée sans modifier la collection d'origine. Par exemple, il existe une collection avec des éléments répétés :

6.1 Déduplication des listes d'éléments

List<Integer> list = Arrays.asList(1,2,3,2,1,4,5,3);
list.stream().distinct().forEach(System.out::print); // 1 2 3 4 5

6.2 Déduplication basée sur un seul attribut de l'objet

//按学生名称去重
List<Student> distintStudents = students.stream().collect(
                Collectors.collectingAndThen(Collectors.toCollection(
                        () -> new TreeSet<>(Comparator.comparing(s -> s.getName()))), ArrayList::new)
        );

6.3 Déduplication basée sur plusieurs attributs d'objets

//根据name与number进行去重
List<Student> distinctStudents = students.stream().collect(
                Collectors.collectingAndThen(Collectors.toCollection(
                        () -> new TreeSet<>(Comparator.comparing(p -> p.getName()+";"+p.getNumber()))), ArrayList::new)
        );

7. filtre filtre

List<Student> studentList = Arrays.asList(
    new Student("Tom", 5),
    new Student("Jenny", 1),
    new Student("Mike", 3),
    new Student("Amy", 2)
));

List<Student> filterStudents = students.stream().filter(s -> s.getNumber()>3).collect(Collectors.toList());

//租户学生列表 filterStudents只剩学生Tom