Astuces Java Stream avancées que vous devez connaître

1. Création d'une carte pour mettre en cache une entité

La mise en cache des entités dans une carte peut améliorer les performances en réduisant le besoin de récupérer à plusieurs reprises des données de la base de données ou d'autres sources de données. Avec Java Streams, vous pouvez facilement créer un tel cache.

Exemple de code

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

Dans le code ci-dessus, nous utilisons Collectors.toMap() pour convertir une liste d'objets User en une carte où la clé est l'ID de l'utilisateur et la valeur est l'objet User lui-même. Cela crée effectivement un cache d'entités utilisateur.

Résultat de la démo

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

2. Création d'une carte imbriquée

Les cartes imbriquées peuvent être utiles lorsque vous devez catégoriser les données en plusieurs niveaux. Par exemple, vous souhaiterez peut-être regrouper les utilisateurs par service, puis par rôle.

Exemple de code

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<String, List<User>>> nestedMap = users.stream()
            .collect(Collectors.groupingBy(User::getDepartment,
                Collectors.groupingBy(User::getRole)));

        System.out.println(nestedMap);
    }
}

Ce code montre comment utiliser Collectors.groupingBy() pour créer une Carte imbriquée. La Map externe regroupe les utilisateurs par département, tandis que la Map interne les regroupe davantage par rôle.

Résultat de la démo

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

3. Création d'une carte avec deux valeurs

Parfois, vous souhaiterez peut-être stocker plusieurs attributs pour une seule clé dans une carte. Utiliser une Carte
>
peut être une solution efficace.

Exemple de code

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<String, Integer>> userMap = users.stream()
            .collect(Collectors.toMap(User::getId, user -> 
                new SimpleEntry<>(user.getName(), user.getAge())));

        System.out.println(userMap);
    }
}

Ici, nous utilisons SimpleEntry pour créer une carte avec deux valeurs (nom et âge) associées à chaque identifiant utilisateur.

Résultat de la démo

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

4. Regroupement par et cartographie

Le regroupement et le mappage peuvent simplifier les transformations de données complexes, telles que la conversion d'une liste d'objets en une Carte groupée où chaque groupe contient des attributs spécifiques.

Exemple de code

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<String>> groupedMap = users.stream()
            .collect(Collectors.groupingBy(User::getDepartment,
                Collectors.mapping(User::getName, Collectors.toList())));

        System.out.println(groupedMap);
    }
}

Dans cet exemple, nous regroupons les utilisateurs par département, puis mappons les objets Utilisateur à leurs noms, créant une Map où chaque département est associé à une liste de noms.

Résultat de la démo

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

5. Regroupement, cartographie et réduction

La combinaison du regroupement, du mappage et de la réduction vous permet d'agréger les données efficacement, par exemple en additionnant des valeurs ou en trouvant la valeur maximale dans chaque groupe.

Exemple de code

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

Dans ce code, nous regroupons les transactions par type, les mappons à leurs montants, puis réduisons les montants en les additionnant. Le résultat est une carte qui montre le montant total pour chaque type de transaction.

Résultat de la démo

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

6.Conclusion

Ces astuces Java Stream avancées peuvent améliorer considérablement l’efficacité et la lisibilité de votre codage. En maîtrisant ces techniques, vous pouvez gérer facilement des tâches de traitement de données complexes. Si vous avez des questions ou avez besoin de précisions, n'hésitez pas à commenter ci-dessous !

Lisez les articles plus sur : 5 astuces avancées de flux Java que vous devez savoir

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!