JAVA 时间工具类-DateUtil

此工具类针对java的Date类汇总了以下功能点集合 ↓↓↓

/**
 * 获取当前日期：getNowDate（yyyy-MM-dd）
 * 获取当前时间：getNowTime （ HH:mm:ss）
 * 获取当前日期时间：getNowDateTime （yyyy-MM-dd HH:mm:ss）
 * 日期路径 即年/月/日：datePath 如2018/08/08
 * 根据传入格式获取当前时间：formatTime date -> yyyy-MM-dd HH:mm:ss
 * 根据传入格式获取当前时间：formatDate date ->yyyy-MM-dd
 * 根据传入格式获取当前时间：parseNowDate format -> date
 * 时间格式化为字符串：parseDateToStr format，date -> String
 * 字符串格式化为时间：parseStrToDate format，String -> date
 * 参数转为Date类型: parseObjectToDate Object -> Date (能处理据大部分时间格式，包含LocalDate等以及毫秒级时间戳转化)
 * LocalDateTime 转 Date：toDate localDateTime -> date
 * LocalDate 转 Date：localDate -> date
 * date转LocalDate date -> LocalDate
 * date转LocalDateTime date -> LocalDateTime
 * 获取服务器启动时间
 * 获取距离今天N天的开始时间：getDayBegin inr -> date
 * 获取距离今天N天的结束时间：getDayEnd int -> date
 * 获取本周的开始时间：getBeginDayOfWeek date -> date
 * 获取本周的结束时间：getEndDayOfWeek  date -> date 
 * 获取今年是哪一年：getYear date -> int
 * 获取本月是哪一月：getMonth date -> int
 * 获取本天是当年哪一周：getWeekOfYear  date -> int
 * 获取本天是当月哪一周：getWeekOfMonth date -> int
 * 获取本天的dd值：getDate date -> int 
 * 获取前n个小时的时间：getDifferHour date,int -> date
 * 返回某个日期相聚几天的日期：getDifferDay  date,int -> date
 * 返回某个日期相聚几月的日期：getDifferMonth date,int -> date
 * 返回某个日期相聚几年的日期：getDifferYear date,int -> date
 * 获取两个日期之间日期的集合：getDays date,date -> List<Date>
 * 获取给定日期i天的日期集合，正数为后i天，负数为前i天：getDays date,int ->  List<Date>
 * 获取给定日期所在周的日期集合：getDaysInWeek date ->  List<Date>
 * 获取某年月份的集合：getMonths int ->  List<String>
 * 获取两个日期之间所有的月份集合：getMonths  date,date -> List<String>

 * 获取两个日期之间相差的天数(日期不分先后)：diffDayNum date,date -> Long
 ^ 获取两个时间中较早或较晚的日期：date,date,int -> date
 */

、

工具类代码：

import org.apache.commons.lang3.time.DateUtils;

import java.lang.management.ManagementFactory;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.concurrent.TimeUnit;


/**
 * 功能点集合
 * 获取当前日期：getNowDate（yyyy-MM-dd）
 * 获取当前时间：getNowTime （ HH:mm:ss）
 * 获取当前日期时间：getNowDateTime （yyyy-MM-dd HH:mm:ss）
 * 日期路径 即年/月/日：datePath 如2018/08/08
 * 根据传入格式获取当前时间：formatTime date -> yyyy-MM-dd HH:mm:ss
 * 根据传入格式获取当前时间：formatDate date ->yyyy-MM-dd
 * 根据传入格式获取当前时间：parseNowDate format -> date
 * 时间格式化为字符串：parseDateToStr format，date -> String
 * 字符串格式化为时间：parseStrToDate format，String -> date
 * 参数转为Date类型: parseObjectToDate Object -> Date (能处理据大部分时间格式，包含LocalDate等以及毫秒级时间戳转化)
 * LocalDateTime 转 Date：toDate localDateTime -> date
 * LocalDate 转 Date：localDate -> date
 * date转LocalDate date -> LocalDate
 * date转LocalDateTime date -> LocalDateTime
 * 获取服务器启动时间
 * 获取距离今天N天的开始时间：getDayBegin inr -> date
 * 获取距离今天N天的结束时间：getDayEnd int -> date
 * 获取本周的开始时间：getBeginDayOfWeek date -> date
 * 获取本周的结束时间：getEndDayOfWeek  date - date
 * 获取今年是哪一年：getYear date -> int
 * 获取本月是哪一月：getMonth date -> int
 * 获取本天是当年哪一周：getWeekOfYear  date -> int
 * 获取本天是当月哪一周：getWeekOfMonth date -> int
 * 获取本天的dd值：getDate date -> int
 * 获取前n个小时的时间：getDifferHour date,int -> date
 * 返回某个日期相聚几天的日期：getDifferDay  date,int -> date
 * 返回某个日期相聚几月的日期：getDifferMonth date,int -> date
 * 返回某个日期相聚几年的日期：getDifferYear date,int -> date
 * 获取两个日期之间日期的集合：getDays date,date -> List<Date>
 * 获取给定日期i天的日期集合，正数为后i天，负数为前i天：getDays date,int ->  List<Date>
 * 获取给定日期所在周的日期集合：getDaysInWeek date ->  List<Date>
 * 获取某年月份的集合：getMonths int ->  List<String>
 * 获取两个日期之间所有的月份集合：getMonths  date,date -> List<String>
 * 获取两个日期之间相差的天数(日期不分先后)：diffDayNum date,date -> Long
 ^ 获取两个时间中较早或较晚的日期：date,date,int -> date
 */



/**
 * Date日期工具类
 *
 * @author MemoryHeart
 * @date 2024/4/17 16:49
 */
public class DateUtils2 {
    public static String YYYY = "yyyy";
    public static String YYYY_MM = "yyyy-MM";
    public static String YYYY_MM_DD = "yyyy-MM-dd";
    public static String HH_MM_SS = "HH:mm:ss";
    public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
    public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
    private static final String[] parsePatterns = {
            "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
            "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM",
            "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"
    };
    private static final String[] parsePatternsLocal = {
            "yyyy-MM-dd'T'HH:mm", "yyyy-MM-dd'T'HH:mm:ss", "yyyy-MM-dd'T'HH:mm:ss.SSS"
    };
    //用于时间的比较
    public static  final int  EARLY = 0;
    public static  final int  LATER = 1;
    /**
     * 获取当前日期
     *
     * @return java.lang.String yyyy-MM-dd
     */
    public static String getNowDate() {
        return parseNowDate(YYYY_MM_DD);
    }

    /**
     * 获取当前时间
     *
     * @return java.lang.String
     */
    public static String getNowTime() {
        return parseNowDate(HH_MM_SS);
    }

    /**
     * 获取当前日期时间
     *
     * @return java.lang.String
     */
    public static String getNowDateTime() {
        return parseNowDate(YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * 日期路径 即年/月/日 如2018/08/08
     *
     * @return ava.lang.String
     */
    public static String datePath() {
        Date now = new Date();
        return parseDateToStr("yyyy/MM/dd", now);
    }

    // public static void main(String[] args) {
    //     DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
    //
    //     LocalDateTime localDate = LocalDateTime.parse("2011-12-12 12:33:11",formatter);
    //     System.out.println(localDate);
    // }

    /**
     * /**
     * 根据传入格式获取当前时间
     *
     * @param date 时间
     * @return java.lang.String
     */
    public static String formatTime(final Date date) {
        DateFormat formatter = new SimpleDateFormat(YYYY_MM_DD_HH_MM_SS);
        return formatter.format(date);
    }


    /**
     * 根据传入格式获取当前时间
     *
     * @param date 时间
     * @return java.lang.String
     */
    public static String formatDate(final Date date) {
        DateFormat formatter = new SimpleDateFormat(YYYY_MM_DD);
        return formatter.format(date);
    }


    /**
     * 根据传入格式获取当前时间
     *
     * @param format 时间格式
     * @return java.lang.String
     */
    public static String parseNowDate(final String format) {
        return parseDateToStr(format, new Date());
    }


    /**
     * 时间格式化为字符串
     *
     * @param format 时间格式
     * @param date   时间
     * @return java.lang.String
     */
    public static String parseDateToStr(String format, Date date) {
        return new SimpleDateFormat(format).format(date);
    }

    /**
     * 字符串格式化为时间
     *
     * @param format 时间格式
     * @param date   时间
     * @return java.util.Date
     */
    public static Date parseStrToDate(String format, String date) {
        try {
            return new SimpleDateFormat(format).parse(date);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }

    /**
      * 使用该方法需要导入此jar包
      *  <dependency>
      *  <groupId>org.apache.commons</groupId>
      *  <artifactId>commons-lang3</artifactId>
      *  <version>3.10</version>
      *  </dependency>
     */
    /**
     * 参数转为Date类型
     *
     * @param obj 参数
     * @return java.util.Date
     */
    public static Date parseObjectToDate(Object obj) {
        if (null == obj) {
            return null;
        }
         String objStr = String.valueOf(obj);
        if (!objStr.contains("T")) {
            try {
                return DateUtils.parseDate(String.valueOf(obj), parsePatterns);
            } catch (ParseException e) {
                // 处理输入为时间戳的情况
                return new Date(Long.parseLong(obj.toString().replace("L", "")));
            }
        } else {
            for (String pattern : parsePatternsLocal) {
                try {
                    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
                    LocalDateTime dateTime = LocalDateTime.parse(objStr, formatter);
                    return Date.from(dateTime.atZone(ZoneId.systemDefault()).toInstant());
                } catch (Exception ignored) {
                }
            }
        }
        return null;
    }

    /**
     * 增加 LocalDateTime 转 Date
     *
     * @param localDateTime 时间
     * @return java.util.Date
     */
    public static Date toDate(LocalDateTime localDateTime) {
        ZonedDateTime zdt = localDateTime.atZone(ZoneId.systemDefault());
        return Date.from(zdt.toInstant());
    }

    /**
     * LocalDate 转 Date
     *
     * @param localDate 日期
     * @return java.util.Date
     */
    public static Date toDate(LocalDate localDate) {
        LocalDateTime localDateTime = LocalDateTime.of(localDate, LocalTime.of(0, 0, 0));
        ZonedDateTime zdt = localDateTime.atZone(ZoneId.systemDefault());
        return Date.from(zdt.toInstant());
    }

    /**
     * date转LocalDate
     *
     * @param date 时间
     * @return java.time.LocalDate
     */
    public static LocalDate toLocalDate(Date date) {
        Instant instant = date.toInstant();
        return instant.atZone(ZoneId.systemDefault()).toLocalDate();
    }

    /**
     * date转LocalDateTime
     *
     * @param date 时间
     * @return java.time.LocalDateTime
     */
    public static LocalDateTime toLocalDateTime(Date date) {
        Instant instant = date.toInstant();
        return instant.atZone(ZoneId.systemDefault()).toLocalDateTime();
    }

    /**
     * 获取服务器启动时间
     *
     * @return java.util.Date
     */
    public static Date getServerStartDate() {
        long time = ManagementFactory.getRuntimeMXBean().getStartTime();
        return new Date(time);
    }

    /**
     * 获取距离今天N天的开始时间
     *
     * @return java.util.Date
     */
    public static Date getDayBegin(int n) {
        // 获取当前日期
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DAY_OF_MONTH, n);
        // 将时间设置为当天的开始时间
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 获取距离今天N天的结束时间
     *
     * @return
     */
    public static Date getDayEnd(int n) {
        // 获取当前日期
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DAY_OF_MONTH, n);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        return calendar.getTime();
    }

    /**
     * 获取本周的开始时间
     *
     * @param date 查询时间（不传则查询本周）
     * @return java.util.Date
     */
    public static Date getBeginDayOfWeek(Date date) {
        // 获取当前日期
        Calendar calendar = Calendar.getInstance();
        if (null != date) {
            calendar.setTime(date);
        }
        // 设置一周的第一天为星期一
        calendar.setFirstDayOfWeek(Calendar.MONDAY);
        // 设置日期为本周的第一天
        calendar.set(Calendar.DAY_OF_WEEK, calendar.getFirstDayOfWeek());
        // 将时间设置为当天的开始时间
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 获取本周的结束时间
     *
     * @param date 查询时间（不传则查询本周）
     * @return java.util.Date
     */
    public static Date getEndDayOfWeek(Date date) {
        // 获取当前日期
        Calendar calendar = Calendar.getInstance();
        if (null != date) {
            calendar.setTime(date);
        }
        // 设置一周的第一天为星期一
        calendar.setFirstDayOfWeek(Calendar.MONDAY);
        // 设置日期为本周的最后一天
        calendar.set(Calendar.DAY_OF_WEEK, calendar.getFirstDayOfWeek() + 6);
        // 将时间设置为当天的结束时间
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 999);
        return calendar.getTime();
    }

    /**
     * 获取今年是哪一年
     *
     * @return int
     */
    public static int getYear(Date date) {
        GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
        gc.setTime(date);
        return gc.get(Calendar.YEAR);
    }

    /**
     * 获取本月是哪一月
     *
     * @return int
     */
    public static int getMonth(Date date) {
        GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
        gc.setTime(date);
        return gc.get(Calendar.MONTH) + 1;
    }

    /**
     * 获取本天是当年哪一周
     *
     * @param date 日期
     * @return int
     */
    public static int getWeekOfYear(Date date) {
        GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
        gc.setTime(date);
        return gc.get(Calendar.WEEK_OF_YEAR);
    }

    /**
     * 获取本天是当月哪一周
     *
     * @param date 日期
     * @return int
     */
    public static int getWeekOfMonth(Date date) {
        GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
        gc.setTime(date);
        return gc.get(Calendar.WEEK_OF_MONTH);
    }

    /**
     * 获取本天的dd值
     *
     * @param date 日期
     * @return int
     */
    public static int getDate(Date date) {
        GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
        gc.setTime(date);
        return gc.get(Calendar.DATE);
    }


    /**
     * 获取前n个小时的时间
     *
     * @param date 日期
     * @param h    相差小时（正数代表后h小时，附负代表前n小时）
     * @return java.Util.Date
     */
    public static Date getDifferHour(Date date, int h) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.set(Calendar.HOUR_OF_DAY, c.get(Calendar.HOUR_OF_DAY) + h);
        return c.getTime();
    }

    /**
     * 返回某个日期相聚几天的日期
     *
     * @param date 日期
     * @param d    天数（正数为后i天的日期，负数为前i天的日期）
     * @return java.util.Date
     */
    public static Date getDifferDay(Date date, int d) {
        Calendar cal = new GregorianCalendar();
        cal.setTime(date);
        cal.set(Calendar.DATE, cal.get(Calendar.DATE) + d);
        return cal.getTime();
    }

    /**
     * 返回某个日期相聚几月的日期
     *
     * @param date 日期
     * @param m    天数（正数为后i月的日期，负数为前i月的日期）
     * @return java.util.Date
     */
    public static Date getDifferMonth(Date date, int m) {
        Calendar cal = new GregorianCalendar();
        cal.setTime(date);
        cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + m);
        return cal.getTime();
    }

    /**
     * 返回某个日期相聚几年的日期
     *
     * @param date 日期
     * @param m    天数（正数为后i年的日期，负数为前i年的日期）
     * @return java.util.Date
     */
    public static Date getDifferYear(Date date, int m) {
        Calendar cal = new GregorianCalendar();
        cal.setTime(date);
        cal.set(Calendar.YEAR, cal.get(Calendar.YEAR) + m);
        return cal.getTime();
    }

    /**
     * 获取两个日期之间日期的集合
     *
     * @param dateStart 开始日期
     * @param dateEnd   结束日期
     * @return java.util.List
     */
    public static List<Date> getDays(Date dateStart, Date dateEnd) {
        List<Date> days = new ArrayList<>();
        Calendar calendarStart = Calendar.getInstance();
        Calendar calendarEnd = Calendar.getInstance();
        calendarStart.setTime(dateStart);
        calendarEnd.setTime(dateEnd);

        while (calendarStart.before(calendarEnd)) {
            days.add(calendarStart.getTime());
            calendarStart.add(Calendar.DAY_OF_YEAR, 1);
        }
        return days;
    }
    /**
     * 获取给定日期i天的日期集合，正数为后i天，负数为前i天
     *
     * @param date 日期
     * @return java.util.List
     */
    public static List<Date> getDays(Date date, int i) {
        List<Date> daysInWeek = new ArrayList<>();
        Calendar calendar = Calendar.getInstance();
        if (null == date){
            date = new Date();
        }
        calendar.setTime(date);
        if (i < 0){
            calendar.add(Calendar.DAY_OF_YEAR ,++i);
            for (int day = 0; day <= Math.abs(i); day++) {
                daysInWeek.add(calendar.getTime());
                calendar.add(Calendar.DAY_OF_YEAR ,1);
            }
        }else {
            for (int day = 0; day < i; day++) {
                daysInWeek.add(calendar.getTime());
                calendar.add(Calendar.DAY_OF_YEAR ,1);
            }
        }
        return daysInWeek;
    }


    /**
     * 获取给定日期所在周的日期集合
     *
     * @param date 日期
     * @return java.util.List
     */
    public static List<Date> getDaysInWeek(Date date) {
        List<Date> daysInWeek = new ArrayList<>();
        Calendar calendar = Calendar.getInstance();
        if (null != date){
            date = new Date();
        }
        Date beginDayOfWeek = getBeginDayOfWeek(date);
        calendar.setTime(beginDayOfWeek);
        for (int day = 0; day < 7; day++) {
            daysInWeek.add(calendar.getTime());
            calendar.add(Calendar.DAY_OF_YEAR ,1);
        }
        return daysInWeek;
    }


    /**
     * 获取某年月份的集合
     *
     * @param year 年份
     * @return java.util.List
     */
    public static List<String> getMonths(Integer year) {
        if (null == year) {
            year = getYear(new Date());
        }
        List<String> yearMonths = new ArrayList<>();
        for (int month = 1; month <= 12; month++) {
            String yearMonth = String.format("%d-%02d", year, month);
            yearMonths.add(yearMonth);
        }
        return yearMonths;
    }

    /**
     * 获取两个日期之间所有的月份集合
     *
     * @param dateStart 开始年份
     * @param dateEnd   结束年份
     * @return java.util.List
     */
    public static List<String> getMonths(Date dateStart, Date dateEnd) {
        if (null == dateStart || null == dateEnd) {
            throw new RuntimeException("开始与结束日期不可为空");
        }
        List<String> yearMonths = new ArrayList<>();
        Calendar startCal = Calendar.getInstance();
        startCal.setTime(dateStart);
        Calendar endCal = Calendar.getInstance();
        endCal.setTime(dateEnd);
        while (startCal.before(endCal) || startCal.equals(endCal)) {
            int year = startCal.get(Calendar.YEAR);
            int month = startCal.get(Calendar.MONTH) + 1; // 月份从0开始，所以要加1
            yearMonths.add(String.format("%d-%02d", year, month));
            startCal.add(Calendar.MONTH, 1); // 月份加1
        }
        return yearMonths;
    }

    /**
     * 获取两个时间中较早或较晚的日期
     *
     * @param day1 日期一
     * @param day2 日期二
     * @param state 状态（Early =0 获取两个时间中更早的时间，Later = 1 获取两个时间中更晚的时间 ）
     * @return java.util.Date
     */
    public static Date getEarlyOrLaterDay(Date day1, Date day2 , int state) {
        if (day1 == null || day2 == null) {
            throw new IllegalArgumentException("日期不能为空");
        }
        if (state != EARLY && state != LATER) {
            throw new IllegalArgumentException("状态参数不正确");
        }
        if (state == EARLY){
            return day1.compareTo(day2) <= 0 ? day1 : day2;
        }else {
            return day1.compareTo(day2) >= 0 ? day1 : day2;
        }
    }
    /**
     * 获取两个日期之间相差的天数(日期不分先后)
     *
     * @param day1 日期一
     * @param day2 日期二
     * @return java.lang.Long
     */
    public static Long diffDayNum(Date day1, Date day2) {
        long diffInMillies = Math.abs(day1.getTime() - day2.getTime());
        return TimeUnit.DAYS.convert(diffInMillies, TimeUnit.MILLISECONDS);
    }


    // public static void main(String[] args) {
    //     System.out.println(diffDayNum(new Date(),getDifferYear(new Date(), -1)));
    // }


}