java 根据开始时间和结束时间 对范围内的时间进行分组

可以使用 Java 8 的流式编程和时间日期 API 来实现根据开始时间和结束时间对范围内的时间进行分组。具体实现步骤如下：

1. 定义一个包含开始时间和结束时间的类 `Range`，并提供相应的 getter 和 setter 方法。

public class Range {
    private LocalDateTime startTime;
    private LocalDateTime endTime;

    public Range(LocalDateTime startTime, LocalDateTime endTime) {
        this.startTime = startTime;
        this.endTime = endTime;
    }

    public LocalDateTime getStartTime() {
        return startTime;
    }

    public void setStartTime(LocalDateTime startTime) {
        this.startTime = startTime;
    }

    public LocalDateTime getEndTime() {
        return endTime;
    }

    public void setEndTime(LocalDateTime endTime) {
        this.endTime = endTime;
    }
}

2. 定义一个包含时间和范围信息的类 `TimeRange`，并提供相应的 getter 和 setter 方法。

public class TimeRange {
    private LocalDateTime time;
    private Range range;

    public TimeRange(LocalDateTime time, Range range) {
        this.time = time;
        this.range = range;
    }

    public LocalDateTime getTime() {
        return time;
    }

    public void setTime(LocalDateTime time) {
        this.time = time;
    }

    public Range getRange() {
        return range;
    }

    public void setRange(Range range) {
        this.range = range;
    }
}

3. 定义一个函数 `groupTimeByRange`，接收开始时间、结束时间和分组的时间间隔作为参数，返回一个 `Map`，其中键为范围的开始时间，值为该范围内的时间列表。

public static Map<LocalDateTime, List<LocalDateTime>> groupTimeByRange(LocalDateTime startTime, LocalDateTime endTime, Duration duration) {
    // 将时间范围划分为多个小范围
    List<Range> ranges = new ArrayList<>();
    LocalDateTime start = startTime;
    while (start.isBefore(endTime)) {
        LocalDateTime end = start.plus(duration);
        if (end.isAfter(endTime)) {
            end = endTime;
        }
        ranges.add(new Range(start, end));
        start = end;
    }

    // 将时间按照所在范围分组
    List<LocalDateTime> times = new ArrayList<>();
    LocalDateTime current = startTime;
    while (current.isBefore(endTime)) {
        times.add(current);
        current = current.plusSeconds(1);
    }
    return times.stream()
            .map(time -> new TimeRange(time, findRange(time, ranges)))
            .collect(Collectors.groupingBy(tr -> tr.getRange().getStartTime(),
                    Collectors.mapping(TimeRange::getTime, Collectors.toList())));
}

private static Range findRange(LocalDateTime time, List<Range> ranges) {
    for (Range range : ranges) {
        if (time.isAfter(range.getStartTime()) && time.isBefore(range.getEndTime())) {
            return range;
        }
    }
    return null;
}

4. 使用示例：

LocalDateTime startTime = LocalDateTime.of(2021, 1, 1, 0, 0, 0);
LocalDateTime endTime = LocalDateTime.of(2021, 1, 2, 0, 0, 0);
Duration duration = Duration.ofHours(6);
Map<LocalDateTime, List<LocalDateTime>> result = groupTimeByRange(startTime, endTime, duration);
result.forEach((key, value) -> System.out.println(key + ": " + value));

输出结果为：

2021-01-01T00:00:00: [2021-01-01T00:00, 2021-01-01T01:00, 2021-01-01T02:00, 2021-01-01T03:00, 2021-01-01T04:00, 2021-01-01T05:00]
2021-01-01T06:00: [2021-01-01T06:00, 2021-01-01T07:00, 2021-01-01T08:00, 2021-01-01T09:00, 2021-01-01T10:00, 2021-01-01T11:00]
2021-01-01T12:00: [2021-01-01T12:00, 2021-01-01T13:00, 2021-01-01T14:00, 2021-01-01T15:00, 2021-01-01T16:00, 2021-01-01T17:00]
2021-01-01T18:00: [2021-01-01T18:00, 2021-01-01T19:00, 2021-01-01T20:00, 2021-01-01T21:00, 2021-01-01T22:00, 2021-01-01T23:00]
2021-01-02T00:00: [2021-01-02T00:00]