时段与时段间用；间隔，时段的起止时间用-来连接的正则表达式，如08:00-08:50；10:00-11:00，小时不能超过24，分钟不能超过60

好的，针对您的需求，可以使用如下正则表达式：

/^(0?[0-9]|1\d|2[0-3]):([0-5][0-9])-(0?[0-9]|1\d|2[0-3]):([0-5][0-9])(；(0?[0-9]|1\d|2[0-3]):([0-5][0-9])-(0?[0-9]|1\d|2[0-3]):([0-5][0-9]))*$/

这个正则表达式的含义是：

- `^` 表示匹配字符串的开头
- `(0?[0-9]|1\d|2[0-3])` 表示小时部分，可以匹配 0-9、00-09、10-19、20-23 四种情况
- `:` 表示匹配冒号
- `([0-5][0-9])` 表示分钟部分，可以匹配 00-59
- `-` 表示匹配连接两个时段的横线
- `；` 表示匹配时段之间的分号，注意分号前后不能有空格
- `*` 表示匹配前面的表达式零次或多次，即可以匹配一个或多个时段

这个正则表达式可以限制输入的时间格式为 `hh:mm-hh:mm`，其中小时部分不能超过 24 小时，分钟部分不能超过 60 分钟。同时，时段之间用分号 `；` 分隔，时段的起止时间用 `-` 连接。

希望对您有所帮助！

相关问题

起止日期的正则表达式

以下是匹配起止日期的正则表达式：

/^\d{4}-\d{2}-\d{2}~\d{4}-\d{2}-\d{2}$/

该正则表达式可以匹配形如"2022-01-01~2022-12-31"的日期范围。其中"\d"表示匹配数字，"{n}"表示匹配n个前面的元素，"-"表示匹配"-"字符，"~"表示匹配"~"字符。

如果需要匹配更多的日期格式，可以使用以下正则表达式：

/^\d{4}-\d{2}-\d{2}( \d{2}:\d{2}:\d{2})?$/  //匹配"2022-01-01"或"2022-01-01 12:00:00"

JAVA 例如： 工作时间段是08:00-09:00;10:00-11:00 工作起止时间是2023-05-25 08:17:00 至 2023-05-26 10:20:00 程序应该返回 08:17-09:00 10:00-11:00 08:00-09:00 10:00-10:20

实现这个功能可以通过以下步骤：

1. 首先，我们需要将工作时间段分割成单独的段，以方便后处理。这可以通过字符串拆分成开始时间结束时间，然后计算出每个时间段的开始和结束时间来实现。为了方便，我们可以使用Java 8中的LocalTime类来处理时间。

2. 接下来，我们需要将工作日程分割成单独的日期，以便我们可以为每个日期计算可用的时间段。这可以通过将起始和终止日期之间的日期计算出来来实现。为了方便，我们可以使用Java 8中的LocalDate类来处理日期。

3. 对于每个日期，我们需要计算可用的时间段。这可以通过迭代每个时间段并使用它与工作时间段进行比较来实现。如果时间段与任何工作时间段重叠，则我们将其调整为重叠的部分。最后，我们将所有可用的时间段合并并返回结果。

下面是一个实现该功能的Java代码示例：

import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;

public class ScheduleParser {
    public static void main(String[] args) {
        String workHours = "08:00-09:00;10:00-11:00";
        LocalDateTime startDateTime = LocalDateTime.of(2023, 5, 25, 8, 17);
        LocalDateTime endDateTime = LocalDateTime.of(2023, 5, 26, 10, 20);
        List<LocalTime> availableTimes = getAvailableTimes(workHours, startDateTime, endDateTime);
        for (LocalTime time : availableTimes) {
            System.out.println(time);
        }
    }

    public static List<LocalTime> getAvailableTimes(String workHours, LocalDateTime startDateTime, LocalDateTime endDateTime) {
        List<LocalTime> availableTimes = new ArrayList<>();
        String[] workTimeRanges = workHours.split(";");
        LocalDate currentDate = startDateTime.toLocalDate();
        while (!currentDate.isAfter(endDateTime.toLocalDate())) {
            for (String workTimeRange : workTimeRanges) {
                String[] parts = workTimeRange.split("-");
                LocalTime startTime = LocalTime.parse(parts[0]);
                LocalTime endTime = LocalTime.parse(parts[1]);
                LocalDateTime currentStartDateTime = LocalDateTime.of(currentDate, startTime);
                LocalDateTime currentEndDateTime = LocalDateTime.of(currentDate, endTime);
                if (currentStartDateTime.isBefore(startDateTime)) {
                    currentStartDateTime = startDateTime;
                }
                if (currentEndDateTime.isAfter(endDateTime)) {
                    currentEndDateTime = endDateTime;
                }
                Duration overlapDuration = getOverlapDuration(currentStartDateTime, currentEndDateTime, startTime, endTime);
                if (!overlapDuration.isZero()) {
                    availableTimes.add(currentStartDateTime.toLocalTime().plus(overlapDuration));
                    availableTimes.add(currentEndDateTime.toLocalTime().minus(overlapDuration));
                }
            }
            currentDate = currentDate.plusDays(1);
        }
        availableTimes.sort(LocalTime::compareTo);
        return availableTimes;
    }

    private static Duration getOverlapDuration(LocalDateTime start1, LocalDateTime end1, LocalTime start2, LocalTime end2) {
        LocalDateTime s1 = LocalDateTime.of(start1.toLocalDate(), start2);
        LocalDateTime e1 = LocalDateTime.of(start1.toLocalDate(), end2);
        LocalDateTime s2 = start1;
        LocalDateTime e2 = end1;
        if (start1.isBefore(s1)) {
            s2 = s1;
        }
        if (end1.isAfter(e1)) {
            e2 = e1;
        }
        return Duration.between(s2, e2);
    }
}

这个示例代码中，我们定义了一个名为getAvailableTimes的方法，它接受工作时间段、起始日期和终止日期作为参数，并返回可用时间段的列表。该方法首先将工作时间段分割成单独的时间段，然后迭代每个日期，并计算可用时间段。在计算可用时间段时，我们将每个时间段与工作时间段进行比较，并将其调整为重叠的部分。最后，我们将所有可用时间段合并并返回结果。