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
{Deposit=300, Withdrawal=80}
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
Top comments (0)