Erweiterte Java-Stream-Tricks, die Sie kennen müssen

1. Erstellen einer Karte zum Zwischenspeichern einer Entität

Das Zwischenspeichern von Entitäten in einer Karte kann die Leistung verbessern, indem die Notwendigkeit verringert wird, Daten wiederholt aus der Datenbank oder anderen Datenquellen abzurufen. Mit Java Streams können Sie einen solchen Cache ganz einfach erstellen.

Beispielcode

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class User {
    private int id;
    private String name;

    // Constructors, getters, setters
}

public class EntityCacheExample {
    public static void main(String[] args) {
        List<user> users = List.of(
            new User(1, "Alice"),
            new User(2, "Bob"),
            new User(3, "Charlie")
        );

        Map<integer user> userCache = users.stream()
            .collect(Collectors.toMap(User::getId, user -> user));

        System.out.println(userCache);
    }
}
</integer></user>

Im obigen Code verwenden wir Collectors.toMap(), um eine Liste von Benutzerobjekten in eine Map zu konvertieren, wobei der Schlüssel die ID des Benutzers und der Wert das Benutzerobjekt selbst ist. Dadurch wird effektiv ein Cache mit Benutzerentitäten erstellt.

Demo-Ergebnis

{1=User{id=1, name='Alice'}, 2=User{id=2, name='Bob'}, 3=User{id=3, name='Charlie'}}

2. Erstellen einer verschachtelten Karte

Verschachtelte Karten können nützlich sein, wenn Sie Daten in mehrere Ebenen kategorisieren müssen. Beispielsweise möchten Sie möglicherweise Benutzer nach ihrer Abteilung und dann nach ihrer Rolle gruppieren.

Beispielcode

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class User {
    private String department;
    private String role;
    private String name;

    // Constructors, getters, setters
}

public class NestedMapExample {
    public static void main(String[] args) {
        List<user> users = List.of(
            new User("HR", "Manager", "Alice"),
            new User("IT", "Developer", "Bob"),
            new User("IT", "Manager", "Charlie")
        );

        Map<string map list>>> nestedMap = users.stream()
            .collect(Collectors.groupingBy(User::getDepartment,
                Collectors.groupingBy(User::getRole)));

        System.out.println(nestedMap);
    }
}
</string></user>

Dieser Code zeigt, wie man mit Collectors.groupingBy() eine verschachtelte Map erstellt. Die äußere Karte gruppiert Benutzer nach Abteilung, während die innere Karte sie weiter nach Rolle gruppiert.

Demo-Ergebnis

{HR={Manager=[User{name='Alice'}]}, IT={Developer=[User{name='Bob'}], Manager=[User{name='Charlie'}]}}

3. Erstellen einer Karte mit zwei Werten

Manchmal möchten Sie möglicherweise mehrere Attribute für einen einzelnen Schlüssel in einer Karte speichern. Verwenden einer Karte
>
kann eine effektive Lösung sein.

Beispielcode

import java.util.List;
import java.util.Map;
import java.util.AbstractMap.SimpleEntry;
import java.util.stream.Collectors;

class User {
    private int id;
    private String name;
    private int age;

    // Constructors, getters, setters
}

public class MapWithTwoValuesExample {
    public static void main(String[] args) {
        List<user> users = List.of(
            new User(1, "Alice", 30),
            new User(2, "Bob", 25),
            new User(3, "Charlie", 35)
        );

        Map<integer map.entry integer>> userMap = users.stream()
            .collect(Collectors.toMap(User::getId, user -> 
                new SimpleEntry(user.getName(), user.getAge())));

        System.out.println(userMap);
    }
}
</integer></user>

Hier verwenden wir SimpleEntry, um eine Karte mit zwei Werten – Name und Alter – zu erstellen, die jeder Benutzer-ID zugeordnet sind.

Demo-Ergebnis

{1=Alice=30, 2=Bob=25, 3=Charlie=35}

4. Gruppieren nach und Zuordnen

Das gemeinsame Gruppieren und Zuordnen kann komplexe Datentransformationen vereinfachen, z. B. das Konvertieren einer Liste von Objekten in eine gruppierte Karte, in der jede Gruppe bestimmte Attribute enthält.

Beispielcode

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class User {
    private String department;
    private String name;

    // Constructors, getters, setters
}

public class GroupingByMappingExample {
    public static void main(String[] args) {
        List<user> users = List.of(
            new User("HR", "Alice"),
            new User("IT", "Bob"),
            new User("HR", "Charlie")
        );

        Map<string list>> groupedMap = users.stream()
            .collect(Collectors.groupingBy(User::getDepartment,
                Collectors.mapping(User::getName, Collectors.toList())));

        System.out.println(groupedMap);
    }
}
</string></user>

In diesem Beispiel gruppieren wir Benutzer nach Abteilung und ordnen dann die Benutzer-Objekte ihren Namen zu und erstellen so eine Karte, in der jede Abteilung einer Namensliste zugeordnet ist.

Demo-Ergebnis

{HR=[Alice, Charlie], IT=[Bob]}

5. Gruppieren nach, Zuordnen und Reduzieren

Durch die Kombination von Gruppierung, Zuordnung und Reduzierung können Sie Daten effizient aggregieren, z. B. Werte summieren oder den Maximalwert in jeder Gruppe ermitteln.

Beispielcode

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class Transaction {
    private String type;
    private int amount;

    // Constructors, getters, setters
}

public class GroupingByMappingReducingExample {
    public static void main(String[] args) {
        List<transaction> transactions = List.of(
            new Transaction("Deposit", 100),
            new Transaction("Deposit", 200),
            new Transaction("Withdrawal", 50),
            new Transaction("Withdrawal", 30)
        );

        Map<string integer> transactionSums = transactions.stream()
            .collect(Collectors.groupingBy(Transaction::getType,
                Collectors.reducing(0, Transaction::getAmount, Integer::sum)));

        System.out.println(transactionSums);
    }
}
</string></transaction>

In diesem Code gruppieren wir Transaktionen nach Typ, ordnen sie ihren Beträgen zu und reduzieren dann die Beträge durch Summieren. Das Ergebnis ist eine Karte, die den Gesamtbetrag für jede Transaktionsart anzeigt.

Demo-Ergebnis

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class User {
    private int id;
    private String name;

    // Constructors, getters, setters
}

public class EntityCacheExample {
    public static void main(String[] args) {
        List<user> users = List.of(
            new User(1, "Alice"),
            new User(2, "Bob"),
            new User(3, "Charlie")
        );

        Map<integer user> userCache = users.stream()
            .collect(Collectors.toMap(User::getId, user -> user));

        System.out.println(userCache);
    }
}
</integer></user>

6. Fazit

Diese fortgeschrittenen Java Stream-Tricks können Ihre Codierungseffizienz und Lesbarkeit erheblich verbessern. Wenn Sie diese Techniken beherrschen, können Sie komplexe Datenverarbeitungsaufgaben problemlos bewältigen. Wenn Sie Fragen haben oder weitere Erläuterungen benötigen, können Sie unten einen Kommentar abgeben!

Weitere Beiträge finden Sie unter: 5 fortgeschrittene Java-Stream-Tricks, die Sie kennen müssen

Das obige ist der detaillierte Inhalt vonErweiterte Java-Stream-Tricks, die Sie kennen müssen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!