Java 8 Streams: Implementing multi-condition filtering, grouping by month and counting statistics

This article explains in detail how to use the Java 8 Streams API to efficiently handle complex data aggregation requirements, including multi-condition filtering, grouping by date and month, and counting statistics for specific event types (such as JOIN/EXIT). By building custom grouping keys and chained Stream operations, the conversion from original data structures to structured statistical results is achieved, and complete code examples and key step analysis are provided.

1. Scenario overview and data model

In daily development, we often need to perform complex aggregation operations on data, such as counting the total number of people of different event types (such as "entry" or "resignation") every month from a set of personnel event records. This tutorial will use a specific Java scenario as an example to demonstrate how to achieve this goal using the Java 8 Stream API.

Suppose we have the following Person event data:

 import java.time.LocalDate;

//Define event type enumeration public enum State {
    JOIN, // Join EXIT // Resign}

//Person class, stores personnel event information public class Person {
    private String id;
    private String name;
    private String surname;
    private State event; // Event type: JOIN or EXIT
    private Object value; // Other values, private LocalDate eventDate is not used in this example; // Event date public Person(String id, State event, LocalDate eventDate) {
        this.id = id;
        this.event = event;
        this.eventDate = eventDate;
    }

    // Getters
    public String getId() { return id; }
    public State getEvent() { return event; }
    public LocalDate getEventDate() { return eventDate; }

    //Add other methods as needed}

Our original data may be stored in a Map>, where the key is the pId and the value is the list of Person events corresponding to the pId.

Ultimately we hope to obtain statistical results in the following form:

 Month Info Total Number
1 JOIN 2
1 EXIT 1
2 EXIT 1
3 JOIN 1

To store this result, we define a data transfer object (DTO):

 public class DTO {
    private int month;
    private State info;
    private int totalEmployees;

    public DTO(int month, State info, int totalEmployees) {
        this.month = month;
        this.info = info;
        this.totalEmployees = totalEmployees;
    }

    // Getters
    public int getMonth() { return month; }
    public State getInfo() { return info; }
    public int getTotalEmployees() { return totalEmployees; }

    @Override
    public String toString() {
        return "DTO{"  
               "month=" month  
               ", info=" info  
               ", totalEmployees=" totalEmployees  
               '}';
    }
}

2. Build custom grouping keys

When performing group statistics, we need a key that can uniquely identify the group. In this example, the grouping is by Month and Event Type. We can create a custom class or the record introduced in Java 16 to serve as this composite key. Using record is a cleaner option:

 // Java 16 uses record as the grouping key public record MonthState(int month, State info) {}

// For Java 8-15, you need a normal class and override equals() and hashCode() methods /*
public class MonthState {
    private int month;
    private State info;

    public MonthState(int month, State info) {
        this.month = month;
        this.info = info;
    }

    public int getMonth() { return month; }
    public State getInfo() { return info; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MonthState that = (MonthState) o;
        return month == that.month && info == that.info;
    }

    @Override
    public int hashCode() {
        return Objects.hash(month, info);
    }
}
*/

record will automatically generate constructors, equals(), hashCode() and toString() methods, which is very suitable as an immutable data carrier.

3. Detailed explanation of Stream API implementation steps

Now, we will build the Stream pipeline step by step to complete the data aggregation:

3.1 Prepare data

First, simulate some raw data:

 import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class StreamAggregationDemo {

    public static void main(String[] args) {
        // Simulate original data Map<string list>&gt; personListById = Map.of(
            "per1", List.of(new Person("per1", State.JOIN, LocalDate.of(2022, 1, 10))),
            "per2", List.of(new Person("per2", State.JOIN, LocalDate.of(2022, 1, 10))),
            "per3", List.of(
                new Person("per3", State.EXIT, LocalDate.of(2022, 1, 10)),
                new Person("per3", State.EXIT, LocalDate.of(2022, 2, 10))
            ),
            "per4", List.of(new Person("per4", State.JOIN, LocalDate.of(2022, 3, 10)))
        );

        // ... Stream pipeline will be constructed here}
}</string>

3.2 Flat processing (flatMap)

Since the original data is a Map>, we need to flatten the Map value (List) into a single stream of Person objects.

 personListById.values().stream() // Get the Stream of all List<person> in the Map
    .flatMap(List::stream) // Flatten each List<person> into a Stream of Person objects</person></person>

3.3 Filter

Next, we only care about the two event types JOIN and EXIT.

 .filter(person -> person.getEvent() == State.EXIT || person.getEvent() == State.JOIN)

3.4 GroupingBy & counting

This is the core step, we will use Collectors.groupingBy() method. It requires two parameters:

1. Classifier function : used to extract grouping keys from elements in the stream. Here we use p -> new MonthState(p.getEventDate().getMonthValue(), p.getEvent()) to create MonthState as the grouping key.
2. Downstream collector : used to aggregate elements in each group. Here we use Collectors.counting() to count the number of elements in each group.

 .collect(Collectors.groupingBy(
    p -> new MonthState(p.getEventDate().getMonthValue(), p.getEvent()), // Grouping key: month and event type Collectors.counting() // Count the elements in each grouping))

This step will return a Map, where the key is the MonthState object and the value is the number of Persons under the combination.

3.5 Conversion results (entrySet().stream().map)

Now that we have a Map, we need to convert it back to the List form we defined.

1. entrySet().stream(): Convert the Map's Entry collection into a Stream>.
2. map(e -> new DTO(e.getKey().month(), e.getKey().info(), (int) (long) e.getValue())): Map each Map.Entry to a DTO object. Note that Collectors.counting() returns Long type and needs to be cast to int.

 .entrySet().stream() // Convert Map to Stream<map.entry long>&gt;
.map(e -&gt; new DTO(e.getKey().month(), e.getKey().info(), (int) (long) e.getValue())) // Map to DTO</map.entry>

3.6 Sorted

To make the results more readable, we can sort the DTO list by month.

 .sorted(Comparator.comparing(DTO::getMonth)) // Sort by month

3.7 Collect results (toList)

Finally, collect all DTO objects in the Stream into a List.

 .toList(); // Collect as List<dto> (Java 16) or .collect(Collectors.toList()) (Java 8-15)</dto>

4. Complete code example

Combine all the above steps to get a complete Stream pipeline:

 import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

//Define event type enumeration enum State {
    JOIN, // Join EXIT // Resign}

// Person class, stores personnel event information class Person {
    private String id;
    private State event; // Event type: JOIN or EXIT
    private LocalDate eventDate; // event date public Person(String id, State event, LocalDate eventDate) {
        this.id = id;
        this.event = event;
        this.eventDate = eventDate;
    }

    public String getId() { return id; }
    public State getEvent() { return event; }
    public LocalDate getEventDate() { return eventDate; }
}

//Group key record MonthState(int month, State info) {}

// Result DTO
class DTO {
    private int month;
    private State info;
    private int totalEmployees;

    public DTO(int month, State info, int totalEmployees) {
        this.month = month;
        this.info = info;
        this.totalEmployees = totalEmployees;
    }

    public int getMonth() { return month; }
    public State getInfo() { return info; }
    public int getTotalEmployees() { return totalEmployees; }

    @Override
    public String toString() {
        return "DTO{"  
               "month=" month  
               ", info=" info  
               ", totalEmployees=" totalEmployees  
               '}';
    }
}

public class StreamAggregationDemo {

    public static void main(String[] args) {
        // Simulate original data Map> personListById = Map.of(
            "per1", List.of(new Person("per1", State.JOIN, LocalDate.of(2022, 1, 10))),
            "per2", List.of(new Person("per2", State.JOIN, LocalDate.of(2022, 1, 10))),
            "per3", List.of(
                new Person("per3", State.EXIT, LocalDate.of(2022, 1, 10)),
                new Person("per3", State.EXIT, LocalDate.of(2022, 2, 10))
            ),
            "per4", List.of(new Person("per4", State.JOIN, LocalDate.of(2022, 3, 10)))
        );

        List result = personListById.values().stream()
            .flatMap(List::stream) // Flatten List
            .filter(person -> person.getEvent() == State.EXIT || person.getEvent() == State.JOIN) // Filter event type.collect(Collectors.groupingBy(
                p -> new MonthState(p.getEventDate().getMonthValue(), p.getEvent()), // Group by month and event type Collectors.counting() // Count the number of each group))
            .entrySet().stream() // Convert Map to Stream
            .map(e -> new DTO(e.getKey().month(), e.getKey().info(), (int) (long) e.getValue())) // Map to DTO
            .sorted(Comparator.comparing(DTO::getMonth)) // Sort by month.toList(); // Collect the results (abbreviation for Java 16, Java 8-15 uses .collect(Collectors.toList()))

        //Print the result result.forEach(System.out::println);
        /*
        Expected output:
        DTO{month=1, info=JOIN, totalEmployees=2}
        DTO{month=1, info=EXIT, totalEmployees=1}
        DTO{month=2, info=EXIT, totalEmployees=1}
        DTO{month=3, info=JOIN, totalEmployees=1}
        */
    }
}

5. Notes and Summary

• Importance of Custom Grouping Key : When you need to group based on multiple properties, it is crucial to create a custom object (such as MonthState) that contains these properties as a grouping key. For Java 8-15, be sure to implement equals() and hashCode() methods correctly; for Java 16, record is an ideal and concise choice.
• Chained calls for Stream operations : Java Stream API implements a declarative data processing method through chained calls (flatMap -> filter -> collect -> map -> sorted -> toList), with high code readability and clear logic.
• Downstream collector : The second parameter of Collectors.groupingBy() is a downstream collector, which determines how to aggregate the elements in each group. Collectors.counting() is used for counting, Collectors.summingInt(), Collectors.averagingDouble(), etc. are used for summing and averaging, and Collectors.mapping() is used for further conversion, etc.
• Type conversion : Collectors.counting() returns the Long type. If the target DTO field is int, explicit type conversion (int) (long) e.getValue() is required.
• Performance considerations : For very large data sets, the Stream API generally performs well, especially if it can be parallelized. However, complex Stream pipelines may also bring certain overhead, and performance testing and optimization should be performed based on actual conditions.

Through this tutorial, you should be able to master how to use the Java 8 Stream API for multi-condition filtering, grouping by composite keys, and counting statistics to efficiently handle complex data aggregation tasks.

The above is the detailed content of Java 8 Streams: Implementing multi-condition filtering, grouping by month and counting statistics. For more information, please follow other related articles on the PHP Chinese website!