如何用Java 8 Time API或第三方库生成时间段列表的缺失间隙？

这个需求其实很常见，你完全不用自己从头写复杂的迭代逻辑——Java 8+的Time API配合流操作就能搞定，要是项目里已经在用Guava这类工具库，那代码会更简洁。我给你两种方案参考：

Java 8引入的Instant类天然对应时间戳，配合简单的排序和遍历就能轻松找出间隙。我们先定义一个时间段的载体（用Java 16+的记录类更简洁，也可以用普通POJO），再实现核心逻辑：

import java.time.Instant;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

// 时间段记录类，封装起始和结束时间
record TimeRange(Instant start, Instant end) {}

public class GapFinder {
    public static List<TimeRange> findMissingGaps(Instant rangeStart, Instant rangeEnd, List<TimeRange> existingRanges) {
        List<TimeRange> gaps = new ArrayList<>();
        
        // 先对现有时间段按起始时间升序排序
        List<TimeRange> sortedRanges = existingRanges.stream()
                .sorted(Comparator.comparing(TimeRange::start))
                .toList();
        
        Instant currentPointer = rangeStart;
        
        for (TimeRange range : sortedRanges) {
            // 如果当前指针在当前时间段起始之前，说明存在间隙
            if (currentPointer.isBefore(range.start())) {
                gaps.add(new TimeRange(currentPointer, range.start()));
            }
            // 更新指针：取当前指针和当前时间段结束的较大值，兼容重叠时间段的情况
            currentPointer = currentPointer.isAfter(range.end()) ? currentPointer : range.end();
        }
        
        // 检查最后一段间隙：如果指针还没到范围终点，补上剩余区间
        if (currentPointer.isBefore(rangeEnd)) {
            gaps.add(new TimeRange(currentPointer, rangeEnd));
        }
        
        return gaps;
    }

    public static void main(String[] args) {
        // 对应示例中的时间戳：100-500范围，现有[150,200]、[230,400]
        Instant rangeStart = Instant.ofEpochMilli(100);
        Instant rangeEnd = Instant.ofEpochMilli(500);
        
        List<TimeRange> existing = List.of(
                new TimeRange(Instant.ofEpochMilli(150), Instant.ofEpochMilli(200)),
                new TimeRange(Instant.ofEpochMilli(230), Instant.ofEpochMilli(400))
        );
        
        List<TimeRange> gaps = findMissingGaps(rangeStart, rangeEnd, existing);
        gaps.forEach(gap -> System.out.printf("Range[%d, %d]%n", gap.start().toEpochMilli(), gap.end().toEpochMilli()));
        // 输出结果：
        // Range[100, 150]
        // Range[200, 230]
        // Range[400, 500]
    }
}

这段代码的优势是完全依赖JDK自带API，无需额外依赖，还自动处理了重叠时间段的情况（比如现有时间段有重叠时，会自动合并后再找间隙）。

如果你的项目已经引入了Guava，那它的RangeSet类已经封装了所有区间操作的逻辑，代码会异常简洁：

首先确保Guava依赖已引入（以Maven为例）：

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>32.1.3-jre</version> <!-- 建议使用最新稳定版 -->
</dependency>

然后实现核心逻辑：

import com.google.common.collect.Range;
import com.google.common.collect.RangeSet;
import com.google.common.collect.TreeRangeSet;
import java.time.Instant;
import java.util.List;
import java.util.stream.Collectors;

public class GuavaGapFinder {
    public static List<Range<Instant>> findMissingGaps(Instant rangeStart, Instant rangeEnd, List<Range<Instant>> existingRanges) {
        // TreeRangeSet会自动排序、合并重叠区间
        RangeSet<Instant> rangeSet = TreeRangeSet.create();
        rangeSet.addAll(existingRanges);
        
        // 获取指定范围内的补集，也就是我们要找的缺失间隙
        Range<Instant> fullRange = Range.closedOpen(rangeStart, rangeEnd); // 注意区间开闭性，和示例逻辑对齐
        RangeSet<Instant> gaps = rangeSet.complement().subRangeSet(fullRange);
        
        // 转化为列表返回
        return gaps.asRanges().stream().collect(Collectors.toList());
    }

    public static void main(String[] args) {
        Instant rangeStart = Instant.ofEpochMilli(100);
        Instant rangeEnd = Instant.ofEpochMilli(500);
        
        List<Range<Instant>> existing = List.of(
                Range.closedOpen(Instant.ofEpochMilli(150), Instant.ofEpochMilli(200)),
                Range.closedOpen(Instant.ofEpochMilli(230), Instant.ofEpochMilli(400))
        );
        
        List<Range<Instant>> gaps = findMissingGaps(rangeStart, rangeEnd, existing);
        gaps.forEach(gap -> System.out.printf("Range[%d, %d]%n", gap.lowerEndpoint().toEpochMilli(), gap.upperEndpoint().toEpochMilli()));
        // 输出结果和纯JDK方案一致
    }
}

Guava的RangeSet帮我们省去了排序、遍历、合并重叠区间的所有细节，直接通过complement()获取补集，代码可读性和简洁性拉满。

注意事项 #

• 如果你的时间戳是秒级而非毫秒级，把Instant.ofEpochMilli()换成Instant.ofEpochSecond()即可
• 注意区间的开闭性：比如示例中的[start, end]对应Guava的closed()，如果是左闭右开则用closedOpen()，根据实际需求调整
• 两种方案都会自动忽略现有时间段中超出指定范围的部分，只聚焦于目标范围内的间隙

内容的提问来源于stack exchange，提问作者ByeBye