判断时间段的重叠情况

判断时间段的重叠情况

概述

本文档介绍了一个Java程序，其中包括了一个时间实体类（TimeEntity）和用于判断时间重叠的方法。时间实体类表示了一个时间段，而判断方法用于确定待判断的时间实体是否与已知时间实体列表中的任何一个时间实体重叠。

例如情况

所有的时间段：[TimeEntity(startTime=19:20, endTime=20:20), TimeEntity(startTime=15:20, endTime=16:20), TimeEntity(startTime=11:30, endTime=12:25), TimeEntity(startTime=09:30, endTime=10:30), TimeEntity(startTime=01:30, endTime=02:30)]
    
待插入的时间段：TimeEntity(startTime=09:30, endTime=10:30)
    
判断待插入的时间段是否能成功插入

时间实体类（TimeEntity）

时间实体类定义了一个时间段，包括开始时间和结束时间。以下是该类的属性和方法：

属性

• startTime: 开始时间，类型为LocalTime。
• endTime: 结束时间，类型为LocalTime。

方法

• 构造函数：初始化开始时间和结束时间。
• getStartTime()：获取开始时间。
• getEndTime()：获取结束时间。

判断时间重叠方法

该方法接收一个已知时间实体列表和待判断的时间实体作为输入，返回一个布尔值表示是否存在重叠。以下是该方法的逻辑：

judgeTime判断时间是否重叠

private static boolean judgeTime(List<TimeEntity> timeEntities, TimeEntity testTimeEntity) {
    if (timeEntities.isEmpty()) {
        return true;
    }
    
    boolean isOverlap = true;
    
    for (TimeEntity timeEntity : timeEntities) {
        isOverlap = isOverlap(testTimeEntity, timeEntity);
        if (!isOverlap) {
            break;
        }
    }
    return isOverlap;
}

参数

• timeEntities：已知的时间实体列表，类型为List。
• testTimeEntity：待判断的时间实体，类型为TimeEntity。

返回值

• 布尔值：表示待判断的时间实体是否与已知时间实体列表中的任何一个时间实体重叠。

方法逻辑

1. 如果已知时间实体列表为空，则返回true。
2. 初始化重叠标志为true。
3. 遍历已知时间实体列表：
   • 调用判断重叠的函数，更新重叠标志。
   • 如果已知时间实体与待判断的时间实体不重叠，则退出循环。
4. 返回重叠标志。

时间重叠判断方法（isOverlap）

该方法用于判断两个时间实体是否重叠。以下是该方法的逻辑：

方法签名

// 判断两个时间实体是否重叠
public static boolean isOverlap(TimeEntity testTimeEntity, TimeEntity timeEntity) {
    LocalTime st = testTimeEntity.getStartTime();
    LocalTime se = testTimeEntity.getEndTime();
    LocalTime ot = timeEntity.getStartTime();
    LocalTime oe = timeEntity.getEndTime();

    //待排课程的开始时间比已有课程的开始时间要大, 且比已有课程的结束时间要大
    if ((st.isAfter(ot) || st.equals(ot)) && (st.isAfter(oe) || st.equals(oe))) {
        return true;
        //待排课程的结束时间比已有课程的开始时间要小, 且比已有课程的开始时间要小
    } else if ((se.isBefore(ot) || se.equals(ot)) && (se.isBefore(oe) || se.equals(oe))) {
        return true;
    }
    return false;
}

参数

• testTimeEntity：待判断的时间实体，类型为TimeEntity。
• timeEntity：已知的时间实体，类型为TimeEntity。

返回值

• 布尔值：表示两个时间实体是否重叠。

方法逻辑

1. 获取待判断时间实体的开始时间和结束时间。
2. 如果待排课程的开始时间晚于或等于已有课程的开始时间，并且早于或等于已有课程的结束时间，则返回true（重叠）。
3. 如果待排课程的结束时间晚于或等于已有课程的开始时间，并且早于或等于已有课程的结束时间，则返回true（重叠）。
4. 其他情况为不重叠，返回false。

示例代码

以下是示例代码，演示了如何使用时间实体类和时间重叠判断方法：

class TimeEntity {
    private LocalTime startTime;
    private LocalTime endTime;

    // 构造函数，初始化开始时间和结束时间
    public TimeEntity(LocalTime startTime, LocalTime endTime) {
        this.startTime = startTime;
        this.endTime = endTime;
    }

    // 获取开始时间
    public LocalTime getStartTime() {
        return startTime;
    }

    // 获取结束时间
    public LocalTime getEndTime() {
        return endTime;
    }
}

public class Demo {
    // 判断待判断的时间实体是否与已知时间实体列表中的任何一个时间实体重叠
    private static boolean judgeTime(List<TimeEntity> timeEntities, TimeEntity testTimeEntity) {
        if (timeEntities.isEmpty()) {
            return true;
        }

        boolean isOverlap = true;

        for (TimeEntity timeEntity : timeEntities) {
            isOverlap = isOverlap(testTimeEntity, timeEntity);
            if (!isOverlap) {
                break;
            }
        }

        return isOverlap;
    }

    // 判断两个时间实体是否重叠
    public static boolean isOverlap(TimeEntity testTimeEntity, TimeEntity timeEntity) {
        LocalTime st = testTimeEntity.getStartTime();
        LocalTime se = testTimeEntity.getEndTime();
        LocalTime ot = timeEntity.getStartTime();
        LocalTime oe = timeEntity.getEndTime();

        //待排课程的开始时间比已有课程的开始时间要大, 且比已有课程的结束时间要大
        if ((st.isAfter(ot) || st.equals(ot)) && (st.isAfter(oe) || st.equals(oe))) {
            return true;
            //待排课程的结束时间比已有课程的开始时间要小, 且比已有课程的开始时间要小
        } else if ((se.isBefore(ot) || se.equals(ot)) && (se.isBefore(oe) || se.equals(oe))) {
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        List<TimeEntity> timeEntities = new ArrayList<>();
        timeEntities.add(new TimeEntity(LocalTime.of(9, 30), LocalTime.of(10, 15)));
        timeEntities.add(new TimeEntity(LocalTime.of(13, 00), LocalTime.of(14, 30)));
        timeEntities.add(new TimeEntity(LocalTime.of(15, 30), LocalTime.of(16, 15)));

        TimeEntity testTimeEntity = new TimeEntity(LocalTime.of(10, 20), LocalTime.of(11, 05));//true
        TimeEntity testTimeEntity1 = new TimeEntity(LocalTime.of(10, 10), LocalTime.of(13, 00));//false
        TimeEntity testTimeEntity2 = new TimeEntity(LocalTime.of(14, 40), LocalTime.of(15, 29));//true
        TimeEntity testTimeEntity3 = new TimeEntity(LocalTime.of(17, 20), LocalTime.of(18, 05));//true

        TimeEntity[] arr = {testTimeEntity, testTimeEntity1, testTimeEntity2, testTimeEntity3};

        for (TimeEntity timeEntity : arr) {
            boolean isCorrect = judgeTime(timeEntities, timeEntity);
            System.out.println(isCorrect);
        }
    }
}