Java: utilisez Stream pour trier le contenu d'une collection

introduction

Vous souhaitez maintenant trier une collection de classes de coordonnées (x, y). Lorsque je cherchais un moyen simple de le faire, il semblait que Stream pouvait être utilisé, alors j'ai essayé de l'utiliser.

C'était bien jusqu'à ce que je le mette sur la console, mais quand je l'ai converti en collection après le tri, je suis resté bloqué, donc je vais le laisser comme mémo.

la mise en oeuvre

Commencez par créer une classe de coordonnées.

Point.java

public class Point{
    int x;
    int y;            

    Point(int x, int y){
        this.x = x;
        this.y = y;
    } 
        
    //getter
    public int getX(){return x;}
    public int getY(){return y;}
}

Utilisez ensuite Stream pour trier la collection de classes de coordonnées. Le contenu du tri est décrit par la méthode «sorted» et comparé en interne à l'aide de la classe «Comparator». J'utilise la méthode thenComparing pour effectuer une sorte de y suivant x.

.collect(Collectors.toCollection(ArrayList::new) Finalement, je l'ai converti en collection, mais j'étais vraiment dedans ici. J'ai pensé que je pourrais simplement utiliser toArrayList.

Main.java

import java.util.ArrayList;
import java.util.Comparator;
import java.util.stream.Stream;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args ) throws Exception {
        ArrayList<Point> node = new ArrayList<Point>();
        
        //Ajouter des coordonnées à la liste
        node.add(new Point(4,3));
        node.add(new Point(2,2));
        node.add(new Point(1,3));
        node.add(new Point(1,1));
        node.add(new Point(2,4));
        node.add(new Point(2,1));
        node.add(new Point(5,3));

        //Avant le tri
        System.out.println("===Before Sort===");
        node.stream().forEach(nodes -> 
            System.out.println("node X:"+nodes.getX()+" Y:"+nodes.getY()));

        //X:Ordre croissant, Y:Trier par ordre croissant et stocker dans ArrayList
        ArrayList<Point> nodeSort = node.stream()
            .sorted(Comparator.comparingInt(Point::getX)   
            .thenComparing(Comparator.comparingInt(Point::getY)))
            .collect(Collectors.toCollection(ArrayList::new));
        
        //Après le tri
        System.out.println("===After Sort===");
        nodeSort.stream().forEach(nodes -> 
            System.out.println("node X:"+nodes.getX()+" Y:"+nodes.getY()));
    }
}

Résultat d'exécution

===Before Sort===
node X:4 Y:3
node X:2 Y:2
node X:1 Y:3
node X:1 Y:1
node X:2 Y:4
node X:2 Y:1
node X:5 Y:3
===After Sort===
node X:1 Y:1
node X:1 Y:3
node X:2 Y:1
node X:2 Y:2
node X:2 Y:4
node X:4 Y:3
node X:5 Y:3

Résumé

Cette fois, j'ai décrit comment trier une collection de classes à l'aide de Stream. En outre, il semble que vous puissiez également extraire des conditions, il est donc très pratique de maîtriser Stream.