new Date().getTime()和Calendar.getInstance().getTimeInMillis()

这两个语句都是获取当前时间的毫秒数，不过前者是JavaScript语言的写法，后者是Java语言的写法。

具体来说，new Date().getTime() 返回的是自1970年1月1日 00:00:00 UTC到当前时间的毫秒数，是一个长整型数值。而Calendar.getInstance().getTimeInMillis() 返回的是当前时间的毫秒数，也是一个长整型数值。在使用上，两者的效果是相同的。

相关问题

JAVA 计算指定工作日的工时 单位（分钟） （不用考虑指定工作日是否在开始结束之间和非工作时段） 1.传入工作时段字符串，格式为String（HH:mm-HH:mm;HH:mm-HH:mm;HH:mm-HH:mm）， 2.传入工作开始日期时间（Date类型） 3.传入工作结束日期时间（Date类型） 4.传入一个指定年月日（Date类型） 5.计算第4步中指定的这天工作日一共工作了有多少（分钟）

以下是一个可能的 Java 实现，可以满足上述要求：

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

public class WorkdayCalculator {

    // 工作时段字符串，格式为 "HH:mm-HH:mm;HH:mm-HH:mm;HH:mm-HH:mm"
    private String workHoursStr;

    public WorkdayCalculator(String workHoursStr) {
        this.workHoursStr = workHoursStr;
    }

    /**
     * 计算指定日期是不是工作日
     * @param date 指定日期
     * @return 是工作日返回 true，否则返回 false
     */
    private boolean isWorkday(Date date) {
        // TODO: 可以根据实际情况实现判断逻辑，比如排除周末、节假日等
        return true;
    }

    /**
     * 计算指定日期的工作时间（单位：分钟）
     * @param date 指定日期
     * @return 工作时间（单位：分钟）
     */
    public int getWorkMinutes(Date date) {
        if (!isWorkday(date)) {
            return 0;
        }
        SimpleDateFormat df = new SimpleDateFormat("HH:mm");
        String dateStr = df.format(date);
        String[] workHours = workHoursStr.split(";");
        int workMinutes = 0;
        for (String workHour : workHours) {
            String[] startEnd = workHour.split("-");
            String startStr = startEnd[0];
            String endStr = startEnd[1];
            try {
                Date start = df.parse(startStr);
                Date end = df.parse(endStr);
                Calendar startTime = Calendar.getInstance();
                startTime.setTime(date);
                startTime.set(Calendar.HOUR_OF_DAY, start.getHours());
                startTime.set(Calendar.MINUTE, start.getMinutes());
                Calendar endTime = Calendar.getInstance();
                endTime.setTime(date);
                endTime.set(Calendar.HOUR_OF_DAY, end.getHours());
                endTime.set(Calendar.MINUTE, end.getMinutes());
                if (startTime.before(endTime)) {
                    if (dateStr.compareTo(startStr) >= 0 && dateStr.compareTo(endStr) <= 0) {
                        workMinutes += (int) ((endTime.getTimeInMillis() - startTime.getTimeInMillis()) / (1000 * 60));
                    }
                } else {
                    // 跨天的情况
                    endTime.add(Calendar.DATE, 1);
                    if (dateStr.compareTo(startStr) >= 0 && dateStr.compareTo("23:59") <= 0) {
                        workMinutes += (int) ((endTime.getTimeInMillis() - startTime.getTimeInMillis()) / (1000 * 60));
                    } else if (dateStr.compareTo("00:00") >= 0 && dateStr.compareTo(endStr) <= 0) {
                        workMinutes += (int) ((endTime.getTimeInMillis() - startTime.getTimeInMillis()) / (1000 * 60));
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return workMinutes;
    }

    public static void main(String[] args) {
        String workHoursStr = "08:30-12:00;13:30-17:30";
        WorkdayCalculator calculator = new WorkdayCalculator(workHoursStr);
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date startDate = df.parse("2022-01-03 08:00:00");
            Date endDate = df.parse("2022-01-05 18:00:00");
            Date targetDate = df.parse("2022-01-04 12:30:00");
            // 计算从 startDate 到 endDate 期间的工作时间
            Calendar cal = Calendar.getInstance();
            cal.setTime(startDate);
            int totalWorkMinutes = 0;
            while (cal.getTime().before(endDate)) {
                totalWorkMinutes += calculator.getWorkMinutes(cal.getTime());
                cal.add(Calendar.MINUTE, 1);
            }
            System.out.println("Total work minutes: " + totalWorkMinutes);
            // 计算 targetDate 当天的工作时间
            int workMinutes = calculator.getWorkMinutes(targetDate);
            System.out.println("Work minutes on " + df.format(targetDate) + ": " + workMinutes);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

这个实现中，`WorkdayCalculator` 类接受一个工作时段字符串作为参数，在构造方法中解析出每个工作时段的开始和结束时间。然后，对于给定的某个日期，可以调用 `getWorkMinutes` 方法计算这一天的工作时间。

在 `getWorkMinutes` 方法中，首先判断这一天是不是工作日，如果不是，则返回 0。然后遍历每个工作时段，解析出开始和结束时间，计算这个时段内的工作时间。如果这个时段跨越了一天（比如上午 9 点到次日下午 3 点），则需要特殊处理。

在 `main` 方法中，演示了如何使用 `WorkdayCalculator` 类计算从某个开始日期到结束日期之间的总工作时间，以及指定日期的工作时间。

java 传入两个日期Date类型 1.获取相隔天数 2.获取相隔的日期是多少

可以使用Java中的`Date`和`Calendar`类来计算两个日期之间的天数和日期。以下是示例代码：

import java.util.Calendar;
import java.util.Date;

public class DateUtils {
    /**
     * 获取两个日期之间相隔的天数
     * @param date1 第一个日期
     * @param date2 第二个日期
     * @return 相隔天数
     */
    public static int getDaysBetween(Date date1, Date date2) {
        // 将日期转换成Calendar类型
        Calendar calendar1 = Calendar.getInstance();
        calendar1.setTime(date1);
        Calendar calendar2 = Calendar.getInstance();
        calendar2.setTime(date2);

        // 获取两个日期的毫秒数并计算相差的天数
        long milliseconds1 = calendar1.getTimeInMillis();
        long milliseconds2 = calendar2.getTimeInMillis();
        long diff = Math.abs(milliseconds2 - milliseconds1);
        int diffDays = (int) (diff / (24 * 60 * 60 * 1000));

        return diffDays;
    }

    /**
     * 获取某个日期之后或之前相隔指定天数的日期
     * @param date 原始日期
     * @param days 相隔天数，可以为负数表示之前的日期
     * @return 相隔指定天数后的日期
     */
    public static Date getDateAfterDays(Date date, int days) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DAY_OF_MONTH, days);
        return calendar.getTime();
    }
}

使用示例：

// 创建两个日期
Date date1 = new Date();
Date date2 = DateUtils.getDateAfterDays(date1, 10);

// 获取相隔天数
int days = DateUtils.getDaysBetween(date1, date2);
System.out.println("相隔天数：" + days);

// 获取相隔日期
Date date3 = DateUtils.getDateAfterDays(date1, 5);
System.out.println("相隔日期：" + date3);

输出结果：

相隔天数：10
相隔日期：Wed Feb 10 14:37:21 CST 2021