Java: Verwenden Sie Stream, um den Inhalt einer Sammlung zu sortieren

Einführung

Jetzt möchten Sie eine Sammlung von Koordinatenklassen (x, y) sortieren. Als ich nach einer einfachen Möglichkeit suchte, schien es, dass Stream verwendet werden könnte, also versuchte ich es.

Es war in Ordnung, bis ich es auf die Konsole legte, aber als ich es nach dem Sortieren in eine Sammlung konvertierte, blieb ich stecken, sodass ich es als Memo belassen werde.

Implementierung

Erstellen Sie zunächst eine Koordinatenklasse.

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

Verwenden Sie dann Stream, um die Sammlung von Koordinatenklassen zu sortieren. Der Inhalt der Sortierung wird nach der Methode "sortiert" beschrieben und intern mit der Klasse "Comparator" verglichen. Ich benutze die "thenComparing" -Methode, um eine Art y nach x auszuführen.

.collect(Collectors.toCollection(ArrayList::new) Schließlich habe ich es in eine Sammlung umgewandelt, aber ich war hier wirklich begeistert. Ich dachte, ich könnte einfach "toArrayList" verwenden.

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>();
        
        //Fügen Sie der Liste Koordinaten hinzu
        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));

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

        //X:Aufsteigende Reihenfolge, Y.:In aufsteigender Reihenfolge sortieren und in ArrayList speichern
        ArrayList<Point> nodeSort = node.stream()
            .sorted(Comparator.comparingInt(Point::getX)   
            .thenComparing(Comparator.comparingInt(Point::getY)))
            .collect(Collectors.toCollection(ArrayList::new));
        
        //Nach dem Sortieren
        System.out.println("===After Sort===");
        nodeSort.stream().forEach(nodes -> 
            System.out.println("node X:"+nodes.getX()+" Y:"+nodes.getY()));
    }
}

Ausführungsergebnis

===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

Zusammenfassung

Dieses Mal habe ich Ihnen gezeigt, wie Sie eine Sammlung von Klassen mit Stream sortieren. Außerdem scheint es, dass Sie auch Bedingungen extrahieren können, so dass es sehr praktisch ist, wenn Sie Stream beherrschen können.