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 users = List.of(
            new User(1, "Alice"),
            new User(2, "Bob"),
            new User(3, "Charlie")
        );

        Map 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 users = List.of(
            new User("HR", "Manager", "Alice"),
            new User("IT", "Developer", "Bob"),
            new User("IT", "Manager", "Charlie")
        );

        Map>> 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 Map imbriquée. La Map externe regroupe les utilisateurs par service, 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 users = List.of(
            new User(1, "Alice", 30),
            new User(2, "Bob", 25),
            new User(3, "Charlie", 35)
        );

        Map> 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 ID 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 users = List.of(
            new User("HR", "Alice"),
            new User("IT", "Bob"),
            new User("HR", "Charlie")
        );

        Map> 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 service, puis mappons les objets Utilisateur à leurs noms, créant ainsi une Map où chaque service 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 de manière efficace, 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 transactions = List.of(
            new Transaction("Deposit", 100),
            new Transaction("Deposit", 200),
            new Transaction("Withdrawal", 50),
            new Transaction("Withdrawal", 30)
        );

        Map 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

{Deposit=300, Withdrawal=80}

6.Conclusion

Ces astuces avancées de Java Stream 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