[Java] Generieren Sie mithilfe der Stream-API eine verengte Liste aus mehreren Listen

Datenbeispiel

Bereiten Sie die folgenden Daten vor.

** Mitarbeiterliste **

** Rollliste **

Ist es nicht eine Struktur, die Sie oft in der DB sehen? Was ist, wenn Sie eine Liste von Mitarbeitern mit einem RollType wünschen, deren Eigentümer wahr ist? Ich denke "bring es mit INNER JOIN aus der DB", aber dieses Mal gehe ich davon aus, dass die Liste unabhängig existiert.

Die tatsächlich erstellte Liste lautet wie folgt.

list.java

List<Staff> staffList = Arrays.asList(
        new Staff("Sato", 1), 
        new Staff("Suzuki", 2), 
        new Staff("Takahashi", 3), 
        new Staff("Tanaka", 4), 
        new Staff("Ito", 5)
);

List<Roll> rollList = Arrays.asList(
        new Roll(1, true), 
        new Roll(2, true), 
        new Roll(3, false), 
        new Roll(4, false), 
        new Roll(5, false)
);

Staff und Roll sind die folgenden Klassen.

SampleClass.java

private class Staff {
    private final String name;
    private final Integer rollType;

    public Staff(String name, Integer rollType) {
        this.name = name;
        this.rollType = rollType;
    }

    public String getName() {
        return this.name;
    }

    public Integer getRollType() {
        return this.rollType;
    }
}

private class Roll {
    private final Integer rollType;
    private final boolean owner;

    public Roll(Integer rollType, boolean owner) {
        this.rollType = rollType;
        this.owner = owner;
    }

    public Integer getRollType() {
        return this.rollType;
    }

    public boolean isOwner() {
        return this.owner;
    }
}

Eigentlich holen

Im Folgenden bereiten wir das Thema Stream und die for-Anweisung als Vergleichsziel vor.

Notation in für Aussage

Main.java

for (Staff staff : StaffList) {
    for (Roll roll : RollList) {
        if (roll.isOwner()) {
            if (staff.getRollType() == roll.getRollType()) {
                System.out.println(staff.getName());
            }
        }
    }
}

Es ist leicht zu verstehen.

Notation im Stream

Main.java

staffList.stream()
        .filter( // 1.
                staff ->
                        rollList.stream()
                                .filter(roll -> roll.isOwner()) //2.
                                .anyMatch(roll -> // 3.
                                        staff.getRollType() == roll.getRollType()
                                )
        )
        .forEach(staff -> System.out.println(staff.getName()));

Um es kurz zu erklären

1. Filtern Sie Mitarbeiter, deren interner Zustand wahr ist
2. Erstellen Sie eine Rollliste, für die der Eigentümer wahr ist
3. Gibt true zurück, wenn sich der RollType des Personals in der Rollliste befindet

Es wird.

Beide Ausführungsergebnisse

Sato Suzuki

Es wird.

Vergleich der Ausführungszeit

Generieren Sie mit jeder Notation eine neue Liste, die die Bedingungen erfüllt (für Verwendungen für eine leere Liste hinzufügen, Stream verwendet Collector). Die Ausführungszeit, wenn dies 1000000 Mal wiederholt wird, ist wie folgt.

Es gibt einen 6-fachen Unterschied. Ich habe es mehrmals versucht, aber dieser Unterschied hat sich (offensichtlich) nicht wesentlich verringert.

Zusätzlich zu der Tatsache, dass Stream ursprünglich nicht schnell ist, scheint die Tatsache, dass Stream einzeln im Filter generiert wird, einen großen Einfluss zu haben.

Wenn es sich um eine einfache Schleife handelt, ist sie streamartiger als die for-Anweisung, aber es ist eine Idee, dass es bisher einen Unterschied in der Leistung gibt.

Zusammenfassung

Erzielen Sie mit Stream einen Pseudo-INNER-JOIN Durch Verschachteln von Filtern ist es möglich, Listen wie Listen zu verarbeiten ... Verwenden Sie die For-Anweisung aus Sicht der Leistung leise

Wenn es eine Methode gibt, mit der derselbe Vorgang beschleunigt werden kann, kommentieren Sie dies bitte.

Verweise

Einführung in die Java Stream API So entfernen Sie doppelte Elemente aus zwei Arrays mit Java Stream und erstellen verschiedene eindeutige Klassen