时段与时段间用；间隔，时段的起止时间用-来连接的正则表达式，如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 分钟。同时，时段之间用分号 `；` 分隔，时段的起止时间用 `-` 连接。

希望对您有所帮助！

相关问题

JAVA 1.传入工作时段字符串，格式为String（HH:mm-HH:mm;HH:mm-HH:mm;HH:mm-HH:mm）， 2.传入工作开始日期时间（Date类型yyyy-MM-dd hh:mm:ss） 3.传入工作结束日期时间（Date类型yyyy-MM-dd hh:mm:ss） 4.计算出这台设备这期间每天的工作起止时间返回List（HH:mm - HH:mm） 例如：工作时间段是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. 将工作时段字符串按照分号分隔成多个时间段；
2. 对于每个时间段，将起止时间分别解析出来；
3. 对于每个工作日，计算出该日的起始时间和结束时间；
4. 对于每个工作日，遍历所有时间段，找到在该日内的时间段；
5. 如果找到了时间段，则计算出该时间段在该日内的起止时间；
6. 如果没有找到时间段，则使用该日内的全天时间作为工作时间段。

下面是Java代码实现：

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class WorkScheduleCalculator {
    private static final DateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private static final DateFormat TIME_FORMAT = new SimpleDateFormat("HH:mm");

    public static List<String> calculate(String workTime, Date start, Date end) throws ParseException {
        List<String> result = new ArrayList<>();

        // 解析工作时段字符串
        String[] timeSegments = workTime.split(";");
        List<TimeSegment> segments = new ArrayList<>();
        for (String timeSegment : timeSegments) {
            String[] times = timeSegment.split("-");
            segments.add(new TimeSegment(TIME_FORMAT.parse(times[0]), TIME_FORMAT.parse(times[1])));
        }

        // 计算每天的工作时段
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(start);
        while (calendar.getTime().before(end)) {
            Date date = calendar.getTime();

            // 计算该日的起始时间和结束时间
            Date startTime = getStartTime(date);
            Date endTime = getEndTime(date);

            // 遍历所有时间段，找到在该日内的时间段
            List<TimeSegment> daySegments = new ArrayList<>();
            for (TimeSegment segment : segments) {
                if (segment.contains(startTime) || segment.contains(endTime)) {
                    // 时间段与该日存在交集，计算出交集部分
                    Date segmentStartTime = segment.getStartTime().after(startTime) ? segment.getStartTime() : startTime;
                    Date segmentEndTime = segment.getEndTime().before(endTime) ? segment.getEndTime() : endTime;
                    daySegments.add(new TimeSegment(segmentStartTime, segmentEndTime));
                }
            }

            // 如果没有找到时间段，则使用该日内的全天时间作为工作时间段
            if (daySegments.isEmpty()) {
                daySegments.add(new TimeSegment(startTime, endTime));
            }

            // 将该日的工作时段添加到结果列表
            for (TimeSegment segment : daySegments) {
                result.add(String.format("%s - %s", TIME_FORMAT.format(segment.getStartTime()), TIME_FORMAT.format(segment.getEndTime())));
            }

            calendar.add(Calendar.DAY_OF_MONTH, 1);
        }

        return result;
    }

    // 获取指定日期的起始时间（即当天的00:00:00）
    private static Date getStartTime(Date date) throws ParseException {
        String dateString = DATE_FORMAT.format(date).substring(0, 10) + " 00:00:00";
        return DATE_FORMAT.parse(dateString);
    }

    // 获取指定日期的结束时间（即当天的23:59:59）
    private static Date getEndTime(Date date) throws ParseException {
        String dateString = DATE_FORMAT.format(date).substring(0, 10) + " 23:59:59";
        return DATE_FORMAT.parse(dateString);
    }

    // 表示一个时间段，包含起始时间和结束时间
    private static class TimeSegment {
        private final Date startTime;
        private final Date endTime;

        public TimeSegment(Date startTime, Date endTime) {
            this.startTime = startTime;
            this.endTime = endTime;
        }

        public Date getStartTime() {
            return startTime;
        }

        public Date getEndTime() {
            return endTime;
        }

        // 判断该时间段是否包含指定时间
        public boolean contains(Date time) {
            return !time.before(startTime) && !time.after(endTime);
        }
    }
}

使用方式如下：

try {
    List<String> workSchedule = WorkScheduleCalculator.calculate(
            "08:00-09:00;10:00-11:00",
            DATE_FORMAT.parse("2023-05-25 08:17:00"),
            DATE_FORMAT.parse("2023-05-26 10:20:00"));
    for (String segment : workSchedule) {
        System.out.println(segment);
    }
} catch (ParseException e) {
    e.printStackTrace();
}

输出结果为：

08:17 - 09:00
10:00 - 11:00
08:00 - 09:00
10:00 - 10:20

JAVA 1.传入工作时段字符串，格式为String（HH:mm-HH:mm;HH:mm-HH:mm;HH:mm-HH:mm）， 2.传入工作开始日期时间（Date类型yyyy-MM-dd hh:mm:ss） 3.传入工作结束日期时间（Date类型yyyy-MM-dd hh:mm:ss） 4.计算出这期间每天的工作起止时间返回List（HH:mm-HH:mm） 例如： 工作时间段是08:00-09:00;10:00-11:00 工作起止时间是2023-05-25 08:17:00 至 2023-05-26 09:00:00 程序应该返回 08:17-09:00 10:00-11:00 08:00-09:00

以下是一个可能的 Java 实现：

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class WorkSchedule {
    public static void main(String[] args) throws Exception {
        String workPeriods = "08:00-09:00;10:00-11:00";
        Date workStartTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2023-05-25 08:17:00");
        Date workEndTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2023-05-26 09:00:00");
        List<String> dailyWorkPeriods = calculateDailyWorkPeriods(workPeriods, workStartTime, workEndTime);
        for (String period : dailyWorkPeriods) {
            System.out.println(period);
        }
    }

    public static List<String> calculateDailyWorkPeriods(String workPeriods, Date workStartTime, Date workEndTime) throws Exception {
        List<String> dailyWorkPeriods = new ArrayList<>();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(workStartTime);
        while (calendar.getTime().compareTo(workEndTime) <= 0) {
            String dateString = dateFormat.format(calendar.getTime());
            List<String> periods = parseWorkPeriods(workPeriods);
            for (String period : periods) {
                String[] startEndTimes = period.split("-");
                Date start = dateFormat.parse(dateString + " " + startEndTimes[0] + ":00");
                Date end = dateFormat.parse(dateString + " " + startEndTimes[1] + ":00");
                if (workStartTime.compareTo(end) < 0 && workEndTime.compareTo(start) > 0) {
                    // 如果工作时间段和当天的时间段有重叠，则取交集作为当天的工作时间段
                    Date dailyStart = workStartTime.compareTo(start) > 0 ? workStartTime : start;
                    Date dailyEnd = workEndTime.compareTo(end) < 0 ? workEndTime : end;
                    String dailyPeriod = new SimpleDateFormat("HH:mm").format(dailyStart) + "-"
                            + new SimpleDateFormat("HH:mm").format(dailyEnd);
                    dailyWorkPeriods.add(dailyPeriod);
                }
            }
            calendar.add(Calendar.DAY_OF_YEAR, 1);
        }
        return dailyWorkPeriods;
    }

    private static List<String> parseWorkPeriods(String workPeriods) {
        String[] periodStrings = workPeriods.split(";");
        List<String> periods = new ArrayList<>();
        for (String periodString : periodStrings) {
            periods.add(periodString.trim());
        }
        return periods;
    }
}

这个实现中，首先使用 `SimpleDateFormat` 类将字符串类型的工作起止时间转换成 `Date` 类型。然后使用 `parseWorkPeriods` 方法将工作时间段字符串解析成每个时间段的起止时间。接着，使用 `Calendar` 类遍历起止日期之间的每一天，并对于每一天，判断工作时间段和当天的时间段是否有重叠，如果有，则取交集作为当天的工作时间段并加入到返回列表中。最后，返回列表包含了每天的工作时间段。