JAVA 需求背景 1.传入日常工作时间段为字符串（HH:mm-HH:mm;HH:mm-HH:mm;HH:mm-HH:mm） 2.传入剩余可用工作时间段为字符串（HH:mm-HH:mm;HH:mm-HH:mm;HH:mm-HH:mm） 3.传入需要的工作时间（分） 3.判断可用工作时间段的时间是否满足需要工作时间（可用计算时 时间段必须对工作时间来说是连续的,两个可用时间段中的时间包含非工作时间时 则这两个时间段算是连续的一个工作时间段） 4.返回true和false

您好！根据您的需求背景，我可以提供以下 Java 代码实现：

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

public class WorkTimeChecker {
    private static final String TIME_FORMAT = "HH:mm";
    
    /**
     * 判断可用工作时间段的时间是否满足需要工作时间（可用计算时 时间段必须对工作时间来说是连续的,
     * 两个可用时间段中的时间包含非工作时间时 则这两个时间段算是连续的一个工作时间段）
     * @param dailyWorkTime 日常工作时间段字符串，格式为：HH:mm-HH:mm;HH:mm-HH:mm;HH:mm-HH:mm
     * @param remainingWorkTime 剩余可用工作时间段字符串，格式为：HH:mm-HH:mm;HH:mm-HH:mm;HH:mm-HH:mm
     * @param requiredWorkTime 需要的工作时间（分钟）
     * @return true表示满足，false表示不满足
     */
    public static boolean check(String dailyWorkTime, String remainingWorkTime, int requiredWorkTime) {
        List<DateRange> dailyRanges = parseTimeRangeString(dailyWorkTime);
        List<DateRange> remainingRanges = parseTimeRangeString(remainingWorkTime);
        
        // 将所有可用时间段合并成一个连续的时间段列表
        List<DateRange> mergedRanges = mergeDateRanges(remainingRanges);
        
        // 判断是否满足需要的工作时间
        int totalWorkTime = 0;
        for (DateRange range : mergedRanges) {
            int workTimeInThisRange = calcWorkTimeInThisRange(dailyRanges, range);
            totalWorkTime += workTimeInThisRange;
            if (totalWorkTime >= requiredWorkTime) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * 将时间段字符串解析成时间段对象列表
     * @param timeRangeStr 时间段字符串，格式为：HH:mm-HH:mm;HH:mm-HH:mm;HH:mm-HH:mm
     * @return 时间段对象列表
     */
    private static List<DateRange> parseTimeRangeString(String timeRangeStr) {
        List<DateRange> ranges = new ArrayList<>();
        String[] rangeStrs = timeRangeStr.split(";");
        for (String rangeStr : rangeStrs) {
            String[] timeStrs = rangeStr.split("-");
            try {
                Date startTime = new SimpleDateFormat(TIME_FORMAT).parse(timeStrs[0]);
                Date endTime = new SimpleDateFormat(TIME_FORMAT).parse(timeStrs[1]);
                ranges.add(new DateRange(startTime, endTime));
            } catch (ParseException e) {
                // 解析失败，忽略该时间段
            }
        }
        return ranges;
    }
    
    /**
     * 将时间段列表合并成连续的时间段列表
     * @param ranges 时间段列表
     * @return 连续的时间段列表
     */
    private static List<DateRange> mergeDateRanges(List<DateRange> ranges) {
        List<DateRange> mergedRanges = new ArrayList<>();
        if (ranges.isEmpty()) {
            return mergedRanges;
        }
        DateRange currentRange = ranges.get(0);
        for (int i = 1; i < ranges.size(); i++) {
            DateRange nextRange = ranges.get(i);
            if (currentRange.isContinuousWith(nextRange)) {
                currentRange = currentRange.mergeWith(nextRange);
            } else {
                mergedRanges.add(currentRange);
                currentRange = nextRange;
            }
        }
        mergedRanges.add(currentRange);
        return mergedRanges;
    }
    
    /**
     * 计算指定时间段内的工作时间
     * @param dailyRanges 日常工作时间段列表
     * @param range 时间段
     * @return 工作时间（分钟）
     */
    private static int calcWorkTimeInThisRange(List<DateRange> dailyRanges, DateRange range) {
        int totalWorkTime = 0;
        for (DateRange dailyRange : dailyRanges) {
            if (dailyRange.isIntersectWith(range)) {
                totalWorkTime += dailyRange.calcWorkTime(range);
            }
        }
        return totalWorkTime;
    }
    
    /**
     * 时间段对象
     */
    private static class DateRange {
        private Date startTime;
        private Date endTime;
        
        public DateRange(Date startTime, Date endTime) {
            this.startTime = startTime;
            this.endTime = endTime;
        }
        
        /**
         * 判断当前时间段是否和另一个时间段连续
         * @param other 另一个时间段
         * @return true表示连续，false表示不连续
         */
        public boolean isContinuousWith(DateRange other) {
            return this.endTime.equals(other.startTime);
        }
        
        /**
         * 合并当前时间段和另一个时间段
         * @param other 另一个时间段
         * @return 合并后的时间段
         */
        public DateRange mergeWith(DateRange other) {
            return new DateRange(this.startTime, other.endTime);
        }
        
        /**
         * 判断当前时间段是否和另一个时间段有重叠部分
         * @param other 另一个时间段
         * @return true表示有重叠部分，false表示没有重叠部分
         */
        public boolean isIntersectWith(DateRange other) {
            return !this.startTime.after(other.endTime) && !this.endTime.before(other.startTime);
        }
        
        /**
         * 计算指定时间段在当前时间段内的工作时间
         * @param target 时间段
         * @return 工作时间（分钟）
         */
        public int calcWorkTime(DateRange target) {
            Date startTime = this.startTime.after(target.startTime) ? this.startTime : target.startTime;
            Date endTime = this.endTime.before(target.endTime) ? this.endTime : target.endTime;
            int workTime = (int) ((endTime.getTime() - startTime.getTime()) / (1000 * 60));
            if (workTime < 0) {
                workTime = 0;
            }
            return workTime;
        }
    }
}

使用示例：

String dailyWorkTime = "09:00-12:00;13:00-18:00";
String remainingWorkTime = "09:00-12:00;14:00-16:00;17:00-18:00";
int requiredWorkTime = 120;

boolean result = WorkTimeChecker.check(dailyWorkTime, remainingWorkTime, requiredWorkTime);

System.out.println(result); // 输出 true

这里假设日常工作时间为 09:00-12:00 和 13:00-18:00，剩余可用工作时间为 09:00-12:00、14:00-16:00 和 17:00-18:00，需要的工作时间为 120 分钟。由于剩余可用工作时间中的时间段可以合并成 09:00-12:00 和 14:00-18:00 两个连续的时间段，因此可用工作时间为 09:00-12:00 和 14:00-18:00，总共的工作时间为 180 分钟，满足需求，因此返回 true。