Welcome back, fellow enthusiasts of functional programming! In our last lecture, we delved into the world of Collectors and explored how they can simplify the process of accumulating data into lists and sets. However, there’s more to Collectors than just these basics. Today, we’ll venture into the fascinating realm of terminal collectors for handling different data structures, such as queues, linked lists, and maps.
Table of contents
Open Table of contents
Sections
The Quest for Versatility: toCollection Method
We’ve already seen how to use Collectors to gather data into lists and sets. But what if you need to collect data into other types of collections, like queues or linked lists? Fear not, for the toCollection method comes to your rescue.
Consider a scenario where you’re uncertain if the data you’re reading from a file is sorted by employee IDs. You want to store all employees in a structure sorted by their IDs. Here, the toSet collector won’t suffice, as it internally returns a HashSet, which doesn’t maintain the order of elements. Instead, you need a TreeSet to achieve the desired sorting.
Stream<Employee> employees = employeeList.stream();
TreeSet<Employee> employeesSorted = employees.collect(Collectors.toCollection(TreeSet::new));
Here, we create a stream of employees and use the toCollection collector to collect them into a TreeSet. However, there’s a catch. To use a TreeSet, you must ensure that the Employee class implements the Comparable interface and defines the compareTo method. This method tells Java how to compare Employee objects based on their IDs, allowing the TreeSet to maintain the desired order.
Mapping Data into Maps: toMap Method
Sometimes, we need to transform data into a map. For instance, you might want to create a map with employee IDs as keys and employee names as values. The toMap collector makes this task a breeze.
Stream<Employee> employees = employeeList.stream();
Map<Integer, String> idToNameMap = employees
.collect(Collectors.toMap(Employee::getId, Employee::getName));
In this code, we create a stream of employees and use the toMap collector. It takes two mapping functions: one to extract the key (employee ID) and the other to extract the value (employee name). The result is a map where each employee ID maps to their corresponding name.
Partitioning Data with Precision: partitioningBy Method
Suppose you want to partition your data into two distinct collections based on a condition. The partitioningBy collector is your ally.
Imagine you want to segregate employees by gender, creating separate collections for males and females. Unlike the filter operation, which retrieves all elements satisfying a condition, partitioningBy returns a map with two entries: true for elements that meet the condition and false for those that don’t.
Stream<Employee> employees = employeeList.stream();
Map<Boolean, List<Employee>> partitionedData = employees
.collect(Collectors.partitioningBy(e -> e.getGender() == Gender.MALE));
Here, we use the partitioningBy collector, specifying the condition to check (gender equals MALE). The result is a map with two lists: true for male employees and false for female employees.
Grouping Data for Insights: groupingBy Method
Sometimes, you need to group your data by a specific criterion, creating multiple collections within a map. The groupingBy collector comes to your aid.
Imagine you want to group employees by their designations, creating a map with designations as keys and lists of corresponding employees as values.
Stream<Employee> employees = employeeList.stream();
Map<String, List<Employee>> groupedData = employees
.collect(Collectors.groupingBy(Employee::getDesignation));
In this code, we employ the groupingBy collector, specifying the classification criterion (employee designation). The result is a map where each designation maps to a list of employees holding that position.
Conclusion
In today’s lesson, we ventured deeper into the powerful world of Collectors. We uncovered how to use the toCollection method to choose the desired collection type, the toMap method to create maps, partitioningBy to split data into two groups, and groupingBy to group data based on specific criteria. These terminal collectors enhance your ability to handle data with precision and versatility, making functional programming an even more potent tool in your development arsenal.
So, fellow learners, continue to sharpen your functional programming skills, exploring the vast landscape of possibilities that await. Until next time, keep coding and keep learning!
You can find the repo for this section of the course Here