Sorting collection date field between two given dates

Since you say that you want to sort, and your example code is a Comparator implementation, I'm going to suppose that the duplication of date 8-Aug-2021 in the example output was unintentional. A bona fide sort will of course only reorder the input objects, not duplicate them or otherwise introduce new ones.

What you're looking for is then just a three-key sort. The first key compares null ahead of non-null. The second key is based on whether the dates are in the chosen window -- those that are sort ahead of those that are not. The third is the natural order of the dates.

The main wrinkle is that to ensure that the first key is computed consistently throughout the sort, you must compute the current date once only, at the time the Comparator is instantiated. This will be a property of the Comparator, in the sense that existing instances will not adjust automatically to the system clock rolling over to a new date.

For example:

final LocalDate today = LocalDate.now();

Comparator<LocalDate> comp = (o1, o2) -> {

    if (o1 == null) {
        return (o2 == null) ? 0 : -1;
    } else if (o2 == null) {
        // At this point, o1 is known to be non-null
        return 1;
    } else {
        // Note: plusDays(2) because that's an _inclusive_ end date for the 3-day
        // range
        boolean outsideWindow1 = o1.isBefore(today) || o1.isAfter(today.plusDays(2));
        boolean outsideWindow2 = o2.isBefore(today) || o2.isAfter(today.plusDays(2));

        if (outsideWindow1 != outsideWindow2) {
            // One date is inside the window and the other outside. then
            // The one inside is sorted ahead of the other
            return outsideWindow1 ? 1 : -1;
        } else {
            // Either both dates are in the 3-day window or both are outside it.
            // Sort by their natural order
            return o1.compareTo(o2);
        }
    }
};

Comparator.nullsFirst(), .comparing() and .thenComparing()

I like John Bollinger’s idea of using an advanced comparator for it all. Here’s my attempt to word it as elegantly as I can.

    LocalDate today = LocalDate.now(ZoneId.systemDefault());
    LocalDate inThreeDays = today.plusDays(3);
    Function<LocalDate, Boolean> notWithinNext3Days = ld -> ld.isBefore(today) || ld.isAfter(inThreeDays);
    Comparator<LocalDate> myComparator = Comparator.nullsFirst(
            Comparator.comparing(notWithinNext3Days)
                    .thenComparing(LocalDate::compareTo));

For consistent results if the code runs across midnight we need to read the clock only once. I am exploiting the fact that the natural ordering of Boolean objects is false before true. Let’s try it with your list.

    list.sort(myComparator);
    list.forEach(System.out::println);

Running on August 9 the output was:

null
2021-08-09
2021-08-10
2021-08-11
2021-08-12
2021-08-01
2021-08-02
2021-08-03
2021-08-08
2021-08-13
2021-08-14
2021-08-15

As you can see, 4 days in all are sorted between null and the rest (August 9 through 12). I didn’t know whether now and the next 3 days meant a 4 day window in all. I trust anyone using my answer to adjust as desired.

You can use Stream#concat as shown below:

List<LocalDate> result = 
    Stream.concat(
        list.stream()
            .filter(Objects::nonNull)
            .filter(date -> !date.isBefore(today) && !date.isAfter(thirdDay)),
        Stream.concat(
            Stream.of(today),
            list.stream()
                .filter(Objects::nonNull)
                .filter(date -> 
                    date.isBefore(today) || date.isAfter(thirdDay)
                ).sorted()
        )
    ).collect(Collectors.toList());

ONLINE DEMO

If you do not want to repeat today's date, you can do it as follows:

List<LocalDate> result = 
    Stream.concat(
        list.stream()
            .filter(Objects::nonNull)
            .filter(date -> !date.isBefore(today) && !date.isAfter(thirdDay)),
        list.stream()
            .filter(Objects::nonNull)
            .filter(date -> date.isBefore(today) || date.isAfter(thirdDay))
            .sorted()
    ).collect(Collectors.toList());

ONLINE DEMO