java计算两天之间的工作日，排除法定节假日

可以使用Java中的Calendar类和Date类来计算两个日期之间的工作日。具体实现可以使用循环来遍历两个日期之间的每一天，然后判断该天是否为工作日，如果是，则累加工作日的天数。在判断工作日时，可以使用Java中的Calendar类的get方法来获取该天是星期几，然后判断是否为周六或周日，以及是否为法定节假日。如果是，则不计入工作日。

相关问题

java计算两个日期之间排除法定节假日和周六周日的工作日天数

可以使用以下步骤来计算两个日期之间排除法定节假日和周六周日的工作日天数：

1. 首先，创建一个包含所有法定节假日的列表。你可以根据你所在的国家或地区来确定这些日期。

2. 然后，创建一个方法来判断给定的日期是否为法定节假日。在该方法中，你可以将给定的日期与法定节假日列表进行比较，如果日期匹配任何一个法定节假日，则返回true，否则返回false。

3. 接下来，创建一个方法来判断给定的日期是否为周末（即星期六或星期日）。你可以使用Java中的Calendar类来获取给定日期的星期几，并判断是否为周末。

4. 然后，创建一个方法来计算两个日期之间的工作日天数。在该方法中，你可以使用一个循环来遍历两个日期之间的每一天。对于每一天，你需要判断它是否为法定节假日或周末，如果不是，则将工作日天数加1。

5. 最后，调用这个方法，并传入要计算的两个日期，即可得到排除法定节假日和周末的工作日天数。

以下是一个简单示例代码：

import java.util.Calendar;

public class WorkingDaysCalculator {
    // 创建法定节假日列表
    private static final String[] HOLIDAYS = {
        "2022-01-01", "2022-01-02", // 示例日期，请根据实际情况修改
        // ... 添加其他法定节假日
    };

    // 判断给定日期是否为法定节假日
    private static boolean isHoliday(String date) {
        for (String holiday : HOLIDAYS) {
            if (holiday.equals(date)) {
                return true;
            }
        }
        return false;
    }

    // 判断给定日期是否为周末
    private static boolean isWeekend(String date) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Integer.parseInt(date.substring(0, 4)), Integer.parseInt(date.substring(5, 7)) - 1,
                Integer.parseInt(date.substring(8)));
        int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
        return dayOfWeek == Calendar.SATURDAY || dayOfWeek == Calendar.SUNDAY;
    }

    // 计算两个日期之间的工作日天数（排除法定节假日和周末）
    public static int calculateWorkingDays(String startDate, String endDate) {
        int workingDays = 0;

        Calendar start = Calendar.getInstance();
        start.set(Integer.parseInt(startDate.substring(0, 4)), Integer.parseInt(startDate.substring(5, 7)) - 1,
                Integer.parseInt(startDate.substring(8)));

        Calendar end = Calendar.getInstance();
        end.set(Integer.parseInt(endDate.substring(0, 4)), Integer.parseInt(endDate.substring(5, 7)) - 1,
                Integer.parseInt(endDate.substring(8)));

        // 循环遍历两个日期之间的每一天
        while (!start.after(end)) {
            String currentDate = String.format("%04d-%02d-%02d", start.get(Calendar.YEAR), start.get(Calendar.MONTH) + 1,
                    start.get(Calendar.DAY_OF_MONTH));

            // 判断当前日期是否为法定节假日或周末
            if (!isHoliday(currentDate) && !isWeekend(currentDate)) {
                workingDays++;
            }

            // 将日期增加一天
            start.add(Calendar.DAY_OF_MONTH, 1);
        }

        return workingDays;
    }

    public static void main(String[] args) {
        String startDate = "2022-01-01"; // 开始日期，请根据实际情况修改
        String endDate = "2022-01-07"; // 结束日期，请根据实际情况修改

        int workingDays = calculateWorkingDays(startDate, endDate);
        System.out.println("工作日天数：" + workingDays);
    }
}

Java 计算两个日期之间的工作日（排除法定节假日和周末，包含调休工作日）

以下是 Java 计算两个日期之间的工作日（排除法定节假日和周末，包含调休工作日）的示例代码：

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.List;

public class WorkingDaysCalculator {
    
    public static long getWorkingDays(LocalDate startDate, LocalDate endDate, List<LocalDate> holidays, List<LocalDate> workingDays) {
        long workingDaysCount = 0;
        LocalDate date = startDate;
        while (date.isBefore(endDate)) {
            if (date.getDayOfWeek() != DayOfWeek.SATURDAY && date.getDayOfWeek() != DayOfWeek.SUNDAY && !holidays.contains(date)) {
                workingDaysCount++;
            } else if (workingDays.contains(date)) {
                workingDaysCount++;
            }
            date = date.plus(1, ChronoUnit.DAYS);
        }
        return workingDaysCount;
    }
    
    public static void main(String[] args) {
        LocalDate startDate = LocalDate.of(2021, 1, 1);
        LocalDate endDate = LocalDate.of(2021, 1, 31);
        List<LocalDate> holidays = new ArrayList<>();
        holidays.add(LocalDate.of(2021, 1, 1));
        holidays.add(LocalDate.of(2021, 1, 6));
        holidays.add(LocalDate.of(2021, 1, 20));
        List<LocalDate> workingDays = new ArrayList<>();
        workingDays.add(LocalDate.of(2021, 1, 2));
        workingDays.add(LocalDate.of(2021, 1, 3));
        long workingDaysCount = getWorkingDays(startDate, endDate, holidays, workingDays);
        System.out.println("Number of working days between " + startDate + " and " + endDate + ": " + workingDaysCount);
    }
}

与前面的示例相比，这个示例增加了一个 `List<LocalDate> workingDays` 参数来表示调休工作日的日期。在 `getWorkingDays` 方法中，我们使用 `while` 循环遍历两个日期之间的每一天，并使用 `getDayOfWeek` 方法来判断一周中的哪一天。如果这一天不是周六或周日，且不是法定节假日，则将其计为工作日；如果这一天是调休工作日，则也计为工作日。最终，我们将工作日数作为方法的返回值，并在 `main` 方法中打印出来。