1. Criando um mapa para armazenar em cache uma entidade

O armazenamento em cache de entidades em um mapa pode melhorar o desempenho, reduzindo a necessidade de buscar dados repetidamente no banco de dados ou em outras fontes de dados. Com Java Streams, você pode criar facilmente esse cache.

Código de exemplo

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

No código acima, usamos Collectors.toMap() para converter uma lista de objetos User em um Mapa onde a chave é o ID do usuário e o valor é o próprio objeto User. Isso efetivamente cria um cache de entidades User.

Resultado da demonstração

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

2. Criando um mapa aninhado

Os mapas aninhados podem ser úteis quando você precisa categorizar dados em vários níveis. Por exemplo, você pode querer agrupar usuários por departamento e, em seguida, por função.

Código de exemplo

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

Este código demonstra como usar Collectors.groupingBy() para criar um Map aninhado. O Mapa externo agrupa os usuários por departamento, enquanto o Mapa interno os agrupa ainda mais por função.

Resultado da demonstração

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

3. Criando um Mapa com Dois Valores

Às vezes, você pode querer armazenar vários atributos para uma única chave em um mapa. Usando um Mapa
>
pode ser uma solução eficaz.

Código de exemplo

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

Aqui, usamos SimpleEntry para criar um mapa com dois valores – nome e idade – associados a cada ID de usuário.

Resultado da demonstração

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

4. Agrupamento por e mapeamento

Agrupar e mapear juntos pode simplificar transformações de dados complexas, como converter uma lista de objetos em um Mapa agrupado onde cada grupo contém atributos específicos.

Código de exemplo

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

Neste exemplo, agrupamos os usuários por departamento e depois mapeamos os objetos User para seus nomes, criando um Map onde cada departamento está associado a uma lista de nomes.

Resultado da demonstração

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

5. Agrupamento por, Mapeamento e Redução

Combinar agrupamento, mapeamento e redução permite agregar dados de forma eficiente, como somar valores ou encontrar o valor máximo em cada grupo.

Código de exemplo

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

Neste código, agrupamos as transações por tipo, mapeamos-nas aos seus valores e depois reduzimos os valores somando-os. O resultado é um Mapa que mostra o valor total de cada tipo de transação.

Resultado da demonstração

{Deposit=300, Withdrawal=80}

6. Conclusão

Esses truques avançados do Java Stream podem melhorar significativamente a eficiência e a legibilidade da codificação. Ao dominar essas técnicas, você poderá lidar com tarefas complexas de processamento de dados com facilidade. Se você tiver alguma dúvida ou precisar de mais esclarecimentos, fique à vontade para comentar abaixo!

Leia mais postagens em: 5 truques avançados de Java Stream que você precisa saber