多个时间段取交集、并集

/**
     * 获取日期中的最大或最小者
     * @param maxOrMin true 最大值 false最小值
     * @param dates 可变参数
     * @return 最大或最小的日期
     */
public static Date getExtremumDate(Boolean maxOrMin, Date... dates){
        List<Date> dates1 = new ArrayList<>(dates.length);
        for (Date date : dates){
            if (date != null){
                dates1.add(date);
            }
        }
        if (dates1.size() == 0){
            return null;
        }
        if (maxOrMin){
            return Collections.max(dates1);
        }else {
            return Collections.min(dates1);
        }
    }

    /**
     * 多个时间段取并集或交集后的时间段列表
     * @param periods 时间段列表
     * @return 时间结果 map beginTime -> endTime
     */
    public static Map<Date, Date> getDateTimeUnion(List<TimePeriodDTO> periods) {
        periods.sort(Comparator.comparing(TimePeriodDTO::getBeginTime));
        Map<Date, Date> dateMap = new TreeMap<>();
        for (TimePeriodDTO period : periods) {
            Date startTime = period.getBeginTime();
            Date endTime = period.getEndTime();
            if (MapUtils.isEmpty(dateMap)) {
                dateMap.put(startTime, endTime);
            }
            Map<Date, Date> tempMap = new TreeMap<>();
            //TreeMap能自动根据Key排序，只需要合并交集
            //1.有交集则合并或取交集
            //2.没有交集则添加
            Iterator<Map.Entry<Date, Date>> iterator = dateMap.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<Date, Date> entry = iterator.next();
                Date start = entry.getKey();
                Date end = entry.getValue();
                //两个时间段 [A, B)、[X, Y)，X < B && A < Y 或者 A < Y && X < B则有交集
                if ((startTime.before(end) && endTime.after(start)) || (start.before(endTime) && end.after(startTime))){
                    iterator.remove();
                    tempMap.put(getExtremumDate(false,startTime,start),getExtremumDate(true,endTime,end));
                }else{
                    if (!iterator.hasNext()){
                        tempMap.put(startTime, endTime);
                    }
                }
            }
            dateMap.putAll(tempMap);
        }
        return dateMap;
    }

    public static Map<Date, Date> getDateTimeIntersection(Date startDate, Date endDate, List<TimePeriodDTO> periods){
        Map<Date, Date> dateMap2 =getDateTimeUnion(periods);
        Map<Date, Date> dateMap = new TreeMap<>();
        if(dateMap2!=null && !dateMap2.isEmpty()){
            for (Map.Entry<Date, Date> entry : dateMap2.entrySet()) {
                if(!(endDate.before(entry.getKey()) || startDate.after(entry.getValue()))){
                    //存在交集 取 两个时间中最大的开始时间和最小的结束时间
                    Date startTime=startDate.before(entry.getKey())? entry.getKey() : startDate;
                    Date finishTime=endDate.before(entry.getValue())? endDate : entry.getValue();
                    dateMap.put(startTime,finishTime);
                }
            }
        }
        return dateMap;
    }

test

@Test
    void test() {

        // 测试数据
        List<TimePeriodDTO> list = new ArrayList<>();

        list.add(new TimePeriodDTO(DateUtil.parseDateTime("2023-06-02 00:00:00"),DateUtil.parseDateTime("2023-06-02 09:00:00")));
        list.add(new TimePeriodDTO(DateUtil.parseDateTime("2023-06-02 12:30:00"),DateUtil.parseDateTime("2023-06-02 14:00:00")));
        list.add(new TimePeriodDTO(DateUtil.parseDateTime("2023-06-02 18:00:00"),DateUtil.parseDateTime("2023-06-02 23:59:59")));

        list.add(new TimePeriodDTO(DateUtil.parseDateTime("2023-06-03 00:00:00"),DateUtil.parseDateTime("2023-06-03 09:00:00")));
        list.add(new TimePeriodDTO(DateUtil.parseDateTime("2023-06-03 12:30:00"),DateUtil.parseDateTime("2023-06-03 14:00:00")));
        list.add(new TimePeriodDTO(DateUtil.parseDateTime("2023-06-03 18:00:00"),DateUtil.parseDateTime("2023-06-03 23:59:59")));

        //求交集
        Map<Date, Date> dateMap1 = TimeUtil.getDateTimeIntersection(DateUtil.parseDateTime("2023-06-02 07:00:00"),DateUtil.parseDateTime("2023-06-03 13:59:59"),list);
        for (Map.Entry<Date, Date> entry : dateMap1.entrySet()) {
            System.out.println("交集开始时间：" + DateUtil.formatDateTime(entry.getKey()) + "      交集结束时间：" + DateUtil.formatDateTime(entry.getValue()));
        }

        System.out.println("=====================================================================");

        //求并集
        Map<Date, Date> dateMap2 =TimeUtil.getDateTimeUnion(list);
        for (Map.Entry<Date, Date> entry : dateMap2.entrySet()) {
            System.out.println("并集开始时间：" + DateUtil.formatDateTime(entry.getKey()) + "      并集结束时间：" + DateUtil.formatDateTime(entry.getValue()));
        }
        Console.log(DateUtil.beginOfDay(DateUtil.parseDateTime("2023-06-03 18:00:00")));
        Console.log(DateUtil.endOfDay(DateUtil.parseDateTime("2023-06-03 18:00:00")));
    }