GroupingBy a range dates

Question

I have a situation like this:

List<ObjectA> collapsed = list.stream().collect(Collectors.collectingAndThen(
        Collectors.groupingBy(
                ObjectA::getDate,
                Collectors.maxBy(Comparator
                        .comparing(ObjectA::getPriority1)
                        .thenComparing(ObjectA::getPriority2)
                        .thenComparing(ObjectA::getDate)
                        .thenComparing(ObjectA::getId))),
        map -> map.values().stream()
                .filter(Optional::isPresent)
                .map(Optional::get)
                .collect(Collectors.toList())));

and it works perfectly for the same dates. I just need to group items for a certain date window:

Integer daysWindow = 90;

so i want everything to happen for the dates in this window. how would this be possible?

Thanks to all!

Something like grouping by year (*4+) and then day of year / 90 or (month number - 1) / 3. — Joop Eggen, Sep 23 '21 at 08:32

Arvind Kumar Avinash · Accepted Answer · 2021-09-23T08:56:36.900

You can apply the filter in the beginning as shown below keeping the rest of the things the same.

LocalDate today = LocalDate.now();

list.stream().filter(obj -> !obj.getDate().isAfter(today.plusDays(90)))
    .collect(Collectors.collectingAndThen(....

Note: I assume ObjectA::getDate is of type java.time.LocalDate.

Demo:

import java.time.LocalDate;

public class Main {
    public static void main(String[] args) {
        // Test
        System.out.println(inRange(LocalDate.now()));
        System.out.println(inRange(LocalDate.of(2021, 12, 31)));
        System.out.println(inRange(LocalDate.of(2022, 2, 20)));
    }

    static boolean inRange(LocalDate date) {
        return !date.isAfter(LocalDate.now().plusDays(90));
    }
}

Output:

true
false
false

ONLINE DEMO

Learn more about the modern Date-Time API^* from Trail: Date Time.

^{* For any reason, if you have to stick to Java 6 or Java 7, you can use ThreeTen-Backport which backports most of the java.time functionality to Java 6 & 7. If you are working for an Android project and your Android API level is still not compliant with Java-8, check Java 8+ APIs available through desugaring and How to use ThreeTenABP in Android Project.}

Note that, in corner cases, if, while streaming, the output of `LocalDate.now()` changes because it is midnight, it may filter out some values and others not. In that case, one *may* want to store the value of `LocalDate.now()` into a variable prior to streaming. — MC Emperor, Sep 23 '21 at 08:48
@MCEmperor - Thanks for the valuable feedback. I've updated the answer to incorporate it. — Arvind Kumar Avinash, Sep 23 '21 at 08:56

score 2 · Answer 2 · answered Sep 23 '21 at 09:07

As another approach, if what you're looking for is a map of date ranges to the corresponding values, you can give it a bit more work by creating a range data type, then generating groups on that type. Here's an example:

class DateRange {
    private final LocalDate from;
    private final int length;

    public DateRange(LocalDate from, int length) {
        super();
        this.from = from;
        this.length = length;
    }

    //getters

    @Override
    public int hashCode() {
        return this.from.hashCode(); //TODO
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof DateRange))
            return false;
        
        DateRange r = (DateRange) obj;

        return this.length == r.length && this.from.equals(r.from);
    }

    @Override
    public String toString() {
        return "(" + from + " to " + from.plusDays(length) + ")";
    }
}

Then your stream can create a mapping, just as the one you currently have, but grouping on date ranges, after determining the range under which each element falls.

int daysWindow = 60;
var start = LocalDate.of(2021, 1, 1);

//example date list
List<LocalDate> dates = List.of(start.plusDays(20), 
        start.plusDays(30), start.plusDays(40), start.plusDays(50),
        start.plusDays(60), start.plusDays(70), start.plusDays(80));

var ranges = dates.stream()
        .collect(Collectors.groupingBy(d -> {
            var diff = ChronoUnit.DAYS.between(start, d);
            return new DateRange(start.plusDays(diff - diff % daysWindow), daysWindow);
        }));

Of course, you'll use your current collector, I just wanted to show the call to groupingBy, which you can still invoke with a downstream collector.

The one thing you need to determine is the value of start. I assume this can be set to the min date in the collection, although it can also be user-defined.

The output of the above code is as follows:

{(2021-03-02 to 2021-05-01)=[2021-03-02, 2021-03-12, 2021-03-22], 
 (2021-01-01 to 2021-03-02)=[2021-01-21, 2021-01-31, 2021-02-10, 2021-02-20]}

And when tested with a different window, int daysWindow = 90;:

{(2021-01-01 to 2021-04-01)=[2021-01-21, 2021-01-31, 2021-02-10, 
                             2021-02-20, 2021-03-02, 2021-03-12, 2021-03-22]}

GroupingBy a range dates

2 Answers2