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 请保证程序不会错误

以下是一个可能的JAVA实现，可以作为参考：

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 WorkTimeCalculator {

    private String workPeriodStr; // 工作时间段字符串
    private List<WorkPeriod> workPeriods = new ArrayList<>(); // 工作时间段列表

    public WorkTimeCalculator(String workPeriodStr) {
        this.workPeriodStr = workPeriodStr;
        parseWorkPeriods();
    }

    /**
     * 解析工作时间段字符串，生成工作时间段列表
     */
    private void parseWorkPeriods() {
        String[] periodStrs = workPeriodStr.split(";");
        for (String periodStr : periodStrs) {
            String[] startEnd = periodStr.split("-");
            if (startEnd.length != 2) {
                throw new IllegalArgumentException("Invalid work period string: " + periodStr);
            }
            WorkPeriod period = new WorkPeriod(parseTime(startEnd[0]), parseTime(startEnd[1]));
            workPeriods.add(period);
        }
    }

    /**
     * 解析时间字符串，生成Date对象
     */
    private Date parseTime(String timeStr) {
        SimpleDateFormat format = new SimpleDateFormat("HH:mm");
        try {
            return format.parse(timeStr);
        } catch (ParseException e) {
            throw new IllegalArgumentException("Invalid time string: " + timeStr);
        }
    }

    /**
     * 计算工作时间段与给定日期时间的交集，返回每天的工作时间段
     */
    public List<String> calculateWorkTimes(Date startDateTime, Date endDateTime) {
        List<String> workTimes = new ArrayList<>();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(startDateTime);
        while (!calendar.getTime().after(endDateTime)) {
            Date date = calendar.getTime();
            List<WorkPeriod> dayWorkPeriods = getDayWorkPeriods(date);
            if (dayWorkPeriods.isEmpty()) {
                // 当天没有工作时间段，跳过
                calendar.add(Calendar.DATE, 1);
                continue;
            }
            // 计算当天的工作时间段
            for (WorkPeriod period : dayWorkPeriods) {
                Date workStart = max(period.getStart(), date);
                Date workEnd = min(period.getEnd(), addDays(date, 1));
                if (!workStart.after(workEnd)) {
                    String workTimeStr = formatTime(workStart) + "-" + formatTime(workEnd);
                    workTimes.add(workTimeStr);
                }
            }
            calendar.add(Calendar.DATE, 1);
        }
        return workTimes;
    }

    /**
     * 获取某一天的工作时间段
     */
    private List<WorkPeriod> getDayWorkPeriods(Date date) {
        List<WorkPeriod> dayWorkPeriods = new ArrayList<>();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        for (WorkPeriod period : workPeriods) {
            if (isSameDay(period.getStart(), date) || isSameDay(period.getEnd(), date)) {
                // 时间段的起始或结束时间在该日期内，加入当天的工作时间段
                dayWorkPeriods.add(period);
            } else if (period.getStart().before(date) && period.getEnd().after(addDays(date, 1))) {
                // 时间段跨越该日期，加入完整的时间段
                dayWorkPeriods.add(period);
            }
        }
        return dayWorkPeriods;
    }

    /**
     * 判断两个日期是否为同一天
     */
    private boolean isSameDay(Date date1, Date date2) {
        Calendar cal1 = Calendar.getInstance();
        cal1.setTime(date1);
        Calendar cal2 = Calendar.getInstance();
        cal2.setTime(date2);
        return cal1.get(Calendar.YEAR) == cal2.get(Calendar.YEAR)
                && cal1.get(Calendar.MONTH) == cal2.get(Calendar.MONTH)
                && cal1.get(Calendar.DATE) == cal2.get(Calendar.DATE);
    }

    /**
     * 获取两个日期中较大的一个
     */
    private Date max(Date date1, Date date2) {
        return date1.after(date2) ? date1 : date2;
    }

    /**
     * 获取两个日期中较小的一个
     */
    private Date min(Date date1, Date date2) {
        return date1.before(date2) ? date1 : date2;
    }

    /**
     * 在给定日期上增加若干天
     */
    private Date addDays(Date date, int days) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DATE, days);
        return calendar.getTime();
    }

    /**
     * 将Date对象格式化为HH:mm字符串
     */
    private String formatTime(Date time) {
        SimpleDateFormat format = new SimpleDateFormat("HH:mm");
        return format.format(time);
    }

    /**
     * 工作时间段类，包含起始时间和结束时间
     */
    private static class WorkPeriod {

        private Date start;
        private Date end;

        public WorkPeriod(Date start, Date end) {
            this.start = start;
            this.end = end;
        }

        public Date getStart() {
            return start;
        }

        public Date getEnd() {
            return end;
        }
    }
}

使用示例：

String workPeriodStr = "08:00-09:00;10:00-11:00";
String startDateTimeStr = "2023-05-25 08:17:00";
String endDateTimeStr = "2023-05-26 10:20:00";

SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date startDateTime = format.parse(startDateTimeStr);
Date endDateTime = format.parse(endDateTimeStr);

WorkTimeCalculator calculator = new WorkTimeCalculator(workPeriodStr);
List<String> workTimes = calculator.calculateWorkTimes(startDateTime, endDateTime);

for (String workTime : workTimes) {
    System.out.println(workTime);
}

输出结果：

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