Java - Stream Filter to get Last Day of several months in a list of dates (not calendar last day)

Query: To filter the data below to find the last date of each month in the list. Note that in this context, the last date of month in the data may or may not match with the last date of the calendar month. The expected output is shown in second list.

Research:

• I believe TemporalAdjusters.lastDayOfMonth() will not help in this case as the last date in the list may or may not match with calendar month's last date.
• I checked several questions on Stack Overflow and I Googled as well, but I was unable to find something similar to my need.

I hope the issue is clear and points me in the direction on how this can be done with streams, as I don't want to use a for loop.

Sample Data:

^Screenshot

Output required:

^Screenshot

Well, a combination of groupingBy and maxBy will probably do.

I assume each record of the table to be of type Event:

record Event(LocalDate date, String model, int start, int end) { }

To get the last days of the month which are within the table, we could utilize groupingBy. In order to group this, we could first create a grouping type. Below, I created an EventGrouping record¹, with a static method to convert an Event to an EventGrouping. Your desired output suggests that you want to group by each year-month-model combination, so we just picked those two properties:

public record EventGrouping(YearMonth yearMonth, String model) {
        
    public static EventGrouping fromEvent(Event event) {
        return new EventGrouping(YearMonth.from(event.date()), event.model());
    }
}

Then, we could get our desired result like this:

events.stream()
    .collect(Collectors.groupingBy(
        EventGrouping::fromEvent,
        Collectors.maxBy(Comparator.comparing(Event::date))
    ));

What happens here is that all stream elements are grouped by our EventGrouping, and then the "maximum value" of each of the event groups is picked. The maximum value is, of course, the most recent date of that certain month.

Note that maxBy returns an Optional, for the case when a group is empty. Also note that the resulting Map is unordered.

We could fix both of these issues by using collectingAndThen and a map factory respectively:

Map<EventGrouping, Event> map = events.stream()
    .collect(groupingBy(
        EventGrouping::fromEvent,
        () -> new TreeMap<>(Comparator.comparing(EventGrouping::yearMonth)
            .thenComparing(EventGrouping::model)),
        collectingAndThen(maxBy(Comparator.comparing(Event::date)), Optional::get)
    ));

^{Note: groupingBy, collectingAndThen and maxBy are all static imports from java.util.stream.Collectors.}

• We added a Supplier of a TreeMap. A TreeMap is a Map implementation with a predictable order by a given comparator. This allows us to iterate over the resulting entries ordered by year–month–model.
• collectingAndThen allows us to apply a function to the result of the given Collector. As already mentioned, maxBy returns an Optional, because maxBy is not applicable if there are no elements in the source stream. However, in our case, this can never happen. So we can safely map the Optional to its contained value.

¹ Instead of writing a custom type, you could also use an existing class holding two arbitrary values, such as a Map.Entry, a Pair or even a List<Object>.