Refactoring with Java 8 Streams

You could do:

public static List<DateBucket> bucketize(
        ZonedDateTime fromDate, 
        ZonedDateTime toDate, 
        int bucketSize, 
        ChronoUnit bucketSizeUnit
    ) {
    
    var result = new ArrayList<DateBucket>();
    IntStream.range(0, Integer.MAX_VALUE)
            .mapToObj(i -> fromDate.plus(i * bucketSize, bucketSizeUnit))
            .takeWhile(d -> d.isBefore(toDate))
            .map(d -> d.toInstant())
            .reduce((min, max) -> {
                result.add(new DateBucket(min, max));
                return max;
            });
    return result;
}

While this reduction function could be considered an abuse of the stream API (reduction functions are supposed to be stateless and associative, which ours is not, but it should be safe in this case since we know that the stream is sequential, and will thus iterate in order), the stream API doesn't seem to offer a more straightforward API to combine adjacent stream elements.

That said, I'd probably prefer your imperative implementation.

The line of thought here is that you want to stream the values needed to create the buckets, then map and collect them. A stream of ZonedDateTimes will do and you can use a Spliterator to create the stream. This seems to be one possible implementation which is basic and doesn't support parallelization, but does seem to work.

public class ZonedDateTimeSpliterator implements Spliterator<ZonedDateTime> {
    private final ZonedDateTime fromDate;
    private final ZonedDateTime toDate;
    private final int bucketSize;
    private final ChronoUnit bucketSizeUnit;
    private ZonedDateTime currentDate;

    public ZonedDateTimeSpliterator(ZonedDateTime fromDate, ZonedDateTime toDate, int bucketSize,
            ChronoUnit bucketSizeUnit) {
        this.fromDate = fromDate;
        this.toDate = toDate;
        this.bucketSize = bucketSize;
        this.bucketSizeUnit = bucketSizeUnit;
        currentDate = fromDate.truncatedTo(bucketSizeUnit);
    }

    public void forEachRemaining(Consumer<? super ZonedDateTime> action) {
        while (currentDate.plus(bucketSize, bucketSizeUnit).isBefore(toDate)) {
            getNext(action);
        }
    }

    private void getNext(Consumer<? super ZonedDateTime> action) {
        action.accept(currentDate);
        currentDate = currentDate.plus(bucketSize, bucketSizeUnit);
    }

    @Override
    public boolean tryAdvance(Consumer<? super ZonedDateTime> action) {
        if (currentDate.plus(bucketSize, bucketSizeUnit).isBefore(toDate)) {
            getNext(action);
            return true;
        } else // cannot advance
            return false;
    }

    @Override
    public Spliterator<ZonedDateTime> trySplit() {
        // implement for parallel processing
        return null;
    }

    @Override
    public long estimateSize() {
        return Duration.between(fromDate.truncatedTo(bucketSizeUnit), toDate.truncatedTo(bucketSizeUnit))
                .get(bucketSizeUnit);
    }

    @Override
    public int characteristics() {
        return ORDERED | SIZED | IMMUTABLE;
    }
}

Then you simply stream the values, map the buckets, and collect the list.

private List<DateBucket> doThing(ZonedDateTime fromDate, ZonedDateTime toDate, int bucketSize,
        ChronoUnit bucketSizeUnit) {
    return StreamSupport
            .stream(() -> new ZonedDateTimeSpliterator(fromDate, toDate, bucketSize, bucketSizeUnit),
                    Spliterator.ORDERED | Spliterator.SIZED | Spliterator.IMMUTABLE, false)
            .map(currentDate -> new DateBucket(currentDate.toInstant(),
                    currentDate.plus(bucketSize, bucketSizeUnit).toInstant()))
            .collect(Collectors.toList());

}

You could range over the number of required buckets by calculating this number in advance using TemporalUnit#between:

public static List<DateBucket> bucketize(ZonedDateTime fromDate, ZonedDateTime toDate,
    int bucketSize, ChronoUnit bucketSizeUnit) {

    return LongStream.range(0, bucketSizeUnit.between(fromDate, toDate)/bucketSize + 1)
        .mapToObj( nb -> new DateBucket(
            fromDate.plus(nb * bucketSize, bucketSizeUnit).toInstant(),
            fromDate.plus((nb+1) * bucketSize, bucketSizeUnit).toInstant()))
        .collect(Collectors.toList());
}