这个需求确实很常见，我之前也帮不少开发者解决过类似的问题。核心思路是把时间范围拆解成起始日、中间完整工作日、结束日三个部分分别计算，再加上节假日和周末的过滤逻辑。下面我给你详细的实现思路和代码片段：

核心实现逻辑 #

• 边界处理：如果起始和结束时间在同一天，直接计算当天8:00-17:00与任务时间段的重叠分钟数
• 分段计算：
  1. 计算起始日的有效分钟（从任务开始时间到当天17:00，若开始时间晚于17:00则为0）
  2. 遍历起始日之后到结束日之前的所有日期，判断是否为工作日（周一至周五）且非节假日，若是则每天加540分钟（9小时）
  3. 计算结束日的有效分钟（从当天8:00到任务结束时间，若结束时间早于8:00则为0）
• 节假日过滤：维护一个节假日日期集合，遍历日期时跳过这些日期

Java 代码示例（使用Java 8+时间API） #

import java.time.DayOfWeek;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.HashSet;
import java.util.Set;

public class WorkTimeCalculator {
    // 示例节假日集合，实际可从数据库/配置文件读取
    private static final Set<LocalDateTime> HOLIDAYS = new HashSet<>();
    static {
        // 添加节假日示例，比如2024年元旦、春节等
        HOLIDAYS.add(LocalDateTime.of(2024, 1, 1, 0, 0));
        HOLIDAYS.add(LocalDateTime.of(2024, 2, 10, 0, 0));
    }

    private static final LocalTime WORK_START = LocalTime.of(8, 0);
    private static final LocalTime WORK_END = LocalTime.of(17, 0);
    private static final long FULL_DAY_MINUTES = 9 * 60; // 540分钟

    public static long calculateMinutesRendered(LocalDateTime start, LocalDateTime end) {
        if (start.isAfter(end)) {
            return 0;
        }

        long totalMinutes = 0;

        // 处理同一天的情况
        if (start.toLocalDate().equals(end.toLocalDate())) {
            return calculateSingleDayMinutes(start, end);
        }

        // 计算起始日的有效时间
        totalMinutes += calculateSingleDayMinutes(start, LocalDateTime.of(start.toLocalDate(), WORK_END));

        // 遍历中间的完整日期
        LocalDateTime currentDate = start.plusDays(1);
        while (currentDate.toLocalDate().isBefore(end.toLocalDate())) {
            if (isWorkDay(currentDate) && !isHoliday(currentDate)) {
                totalMinutes += FULL_DAY_MINUTES;
            }
            currentDate = currentDate.plusDays(1);
        }

        // 计算结束日的有效时间
        totalMinutes += calculateSingleDayMinutes(LocalDateTime.of(end.toLocalDate(), WORK_START), end);

        return totalMinutes;
    }

    // 计算单天内的有效分钟数
    private static long calculateSingleDayMinutes(LocalDateTime periodStart, LocalDateTime periodEnd) {
        LocalTime start = periodStart.toLocalTime();
        LocalTime end = periodEnd.toLocalTime();

        // 时间段在工作时间之外，返回0
        if (end.isBefore(WORK_START) || start.isAfter(WORK_END)) {
            return 0;
        }

        // 取重叠时间段的起始和结束
        LocalTime actualStart = start.isBefore(WORK_START) ? WORK_START : start;
        LocalTime actualEnd = end.isAfter(WORK_END) ? WORK_END : end;

        return java.time.Duration.between(actualStart, actualEnd).toMinutes();
    }

    // 判断是否为工作日（周一至周五）
    private static boolean isWorkDay(LocalDateTime dateTime) {
        DayOfWeek day = dateTime.getDayOfWeek();
        return day != DayOfWeek.SATURDAY && day != DayOfWeek.SUNDAY;
    }

    // 判断是否为节假日
    private static boolean isHoliday(LocalDateTime dateTime) {
        // 仅比较日期部分，忽略时间
        return HOLIDAYS.stream().anyMatch(holiday -> holiday.toLocalDate().equals(dateTime.toLocalDate()));
    }

    public static void main(String[] args) {
        LocalDateTime taskStart = LocalDateTime.of(2024, 5, 20, 9, 30);
        LocalDateTime taskEnd = LocalDateTime.of(2024, 5, 23, 16, 0);
        long minutes = calculateMinutesRendered(taskStart, taskEnd);
        System.out.println("有效分钟数：" + minutes); // 预期：(7.5*60) + 540 + (8*60) = 450+540+480=1470
    }
}

Python 代码示例 #

from datetime import datetime, time, timedelta

# 示例节假日集合，实际可从数据库/配置文件读取
HOLIDAYS = {
    datetime(2024, 1, 1).date(),
    datetime(2024, 2, 10).date()
}

WORK_START = time(8, 0)
WORK_END = time(17, 0)
FULL_DAY_MINUTES = 9 * 60  # 540分钟

def calculate_minutes_rendered(start: datetime, end: datetime) -> int:
    if start > end:
        return 0
    
    total_minutes = 0

    # 处理同一天的情况
    if start.date() == end.date():
        return calculate_single_day_minutes(start, end)
    
    # 计算起始日的有效时间
    start_day_end = datetime.combine(start.date(), WORK_END)
    total_minutes += calculate_single_day_minutes(start, start_day_end)

    # 遍历中间的完整日期
    current_date = start.date() + timedelta(days=1)
    while current_date < end.date():
        if is_work_day(current_date) and current_date not in HOLIDAYS:
            total_minutes += FULL_DAY_MINUTES
        current_date += timedelta(days=1)
    
    # 计算结束日的有效时间
    end_day_start = datetime.combine(end.date(), WORK_START)
    total_minutes += calculate_single_day_minutes(end_day_start, end)

    return total_minutes

def calculate_single_day_minutes(period_start: datetime, period_end: datetime) -> int:
    start_time = period_start.time()
    end_time = period_end.time()

    # 时间段在工作时间之外
    if end_time < WORK_START or start_time > WORK_END:
        return 0
    
    # 确定实际的起始和结束时间
    actual_start = max(start_time, WORK_START)
    actual_end = min(end_time, WORK_END)

    # 计算分钟差
    start_dt = datetime.combine(datetime.today(), actual_start)
    end_dt = datetime.combine(datetime.today(), actual_end)
    return int((end_dt - start_dt).total_seconds() // 60)

def is_work_day(date) -> bool:
    # 周一到周五是工作日（weekday()返回0=周一，4=周五）
    return date.weekday() < 5

if __name__ == "__main__":
    task_start = datetime(2024, 5, 20, 9, 30)
    task_end = datetime(2024, 5, 23, 16, 0)
    minutes = calculate_minutes_rendered(task_start, task_end)
    print(f"有效分钟数：{minutes}")  # 预期结果：1470

注意事项 #

• 节假日集合需要根据实际需求维护，比如可以从外部配置文件、数据库拉取，或者调用第三方节假日API（但要注意依赖问题）
• 代码中默认工作时段是8:00-17:00，你可以根据实际情况修改WORK_START和WORK_END变量
• 对于跨时区的场景，需要额外处理时区转换，确保所有时间都统一到同一个时区计算

内容的提问来源于stack exchange，提问作者Audrick