dvanced Java Stream Tricks You Need to Know

1. Creating a Map to Cache an Entity

Caching entities in a Map can improve performance by reducing the need to repeatedly fetch data from the database or other data sources. With Java Streams, you can easily create such a cache.

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

In the above code, we use Collectors.toMap() to convert a list of User objects into a Map where the key is the user’s ID and the value is the User object itself. This effectively creates a cache of User entities.

Demo Result

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

2. Creating a Nested Map

Nested Maps can be useful when you need to categorize data into multiple levels. For example, you might want to group users by their department and then by their role.

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

This code demonstrates how to use Collectors.groupingBy() to create a nested Map. The outer Map groups users by department, while the inner Map further groups them by role.

Demo Result

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

3. Creating a Map with Two Values

Sometimes, you may want to store multiple attributes for a single key in a Map. Using a Map
>
can be an effective solution.

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

Here, we use SimpleEntry to create a Map with two values—name and age—associated with each user ID.

Demo Result

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

4. Grouping By and Mapping

Grouping and mapping together can simplify complex data transformations, such as converting a list of objects into a grouped Map where each group contains specific attributes.

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

In this example, we group users by department and then map the User objects to their names, creating a Map where each department is associated with a list of names.

Demo Result

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

5. Grouping By, Mapping, and Reducing

Combining grouping, mapping, and reducing allows you to aggregate data efficiently, such as summing values or finding the maximum value in each group.

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

In this code, we group transactions by type, map them to their amounts, and then reduce the amounts by summing them. The result is a Map that shows the total amount for each transaction type.

Demo Result

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

These advanced Java Stream tricks can significantly enhance your coding efficiency and readability. By mastering these techniques, you can handle complex data processing tasks with ease. If you have any questions or need further clarification, feel free to comment below!

Read posts more at : 5 Advanced Java Stream Tricks You Need to Know

The above is the detailed content of dvanced Java Stream Tricks You Need to Know. For more information, please follow other related articles on the PHP Chinese website!