1. Crear un mapa para almacenar en caché una entidad

El almacenamiento en caché de entidades en un mapa puede mejorar el rendimiento al reducir la necesidad de recuperar datos repetidamente de la base de datos u otras fuentes de datos. Con Java Streams, puede crear fácilmente dicho caché.

Código de ejemplo

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

En el código anterior, usamos Collectors.toMap() para convertir una lista de objetos de Usuario en un Mapa donde la clave es la ID del usuario y el valor es el objeto de Usuario en sí. Esto crea efectivamente un caché de entidades de usuario.

Resultado de la demostración

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

2. Creando un mapa anidado

Los mapas anidados pueden resultar útiles cuando necesitas categorizar datos en varios niveles. Por ejemplo, es posible que desee agrupar a los usuarios por departamento y luego por función.

Código de ejemplo

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 demuestra cómo usar Collectors.groupingBy() para crear un Mapa anidado. El Mapa externo agrupa a los usuarios por departamento, mientras que el Mapa interno los agrupa aún más por función.

Resultado de la demostración

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

3. Creando un mapa con dos valores

A veces, es posible que desees almacenar varios atributos para una sola clave en un mapa. Usando un Mapa
>
puede ser una solución eficaz.

Código de ejemplo

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

Aquí usamos SimpleEntry para crear un mapa con dos valores (nombre y edad) asociados con cada ID de usuario.

Resultado de la demostración

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

4. Agrupación y mapeo

Agrupar y mapear juntos puede simplificar transformaciones de datos complejas, como convertir una lista de objetos en un Mapa agrupado donde cada grupo contiene atributos específicos.

Código de ejemplo

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

En este ejemplo, agrupamos usuarios por departamento y luego asignamos los objetos Usuario a sus nombres, creando un Mapa donde cada departamento está asociado con una lista de nombres.

Resultado de la demostración

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

5. Agrupar, mapear y reducir

Combinar agrupación, mapeo y reducción le permite agregar datos de manera eficiente, como sumar valores o encontrar el valor máximo en cada grupo.

Código de ejemplo

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

En este código, agrupamos transacciones por tipo, las asignamos a sus montos y luego reducimos los montos sumándolos. El resultado es un mapa que muestra el monto total para cada tipo de transacción.

Resultado de la demostración

{Deposit=300, Withdrawal=80}

6. Conclusión

Estos trucos avanzados de Java Stream pueden mejorar significativamente la eficiencia y legibilidad de la codificación. Al dominar estas técnicas, podrá manejar tareas complejas de procesamiento de datos con facilidad. Si tiene alguna pregunta o necesita más aclaraciones, ¡no dude en comentar a continuación!

Lea más publicaciones en: 5 trucos avanzados de Java Stream que necesita saber