史上最全Java7日期时间工具类

文章目录

这是我总结的Java7日期工具类,应该是比较全面的,满足日常开发绝大部分需求,分享给大家,有错误之处,还望大神指教。

/**
 * 日期时间工具类
 *
 * @author JourWon
 * @date 2020/12/5
 */
public class DateUtils {

    /**
     * 显示年月日时分秒,例如 2015-08-11 09:51:53.
     */
    public static final String DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

    /**
     * 显示年月日时分,例如 2015-08-11 09:51.
     */
    public static final String NO_SECOND_DATETIME_PATTERN = "yyyy-MM-dd HH:mm";

    /**
     * 仅显示年月日,例如 2015-08-11.
     */
    public static final String DATE_PATTERN = "yyyy-MM-dd";

    /**
     * 仅显示时分秒,例如 09:51:53.
     */
    public static final String TIME_PATTERN = "HH:mm:ss";

    /**
     * 显示年月日时分秒(由/分割),例如 2015/08/11 09:51:53.
     */
    public static final String DATETIME_PATTERN_WITH_SLASH = "yyyy/MM/dd HH:mm:ss";

    /**
     * 显示年月日(由/分割),例如 2015/08/11.
     */
    public static final String DATE_PATTERN_WITH_SLASH = "yyyy/MM/dd";

    /**
     * 显示年月日时分秒(无符号),例如 20150811095153.
     */
    public static final String UNSIGNED_DATETIME_PATTERN = "yyyyMMddHHmmss";

    /**
     * 仅显示年月日(无符号),例如 20150811.
     */
    public static final String UNSIGNED_DATE_PATTERN = "yyyyMMdd";

    /**
     * 仅显示年(无符号),例如 2015.
     */
    private static final String YEAR_PATTERN = "yyyy";

    /**
     * 仅显示年月,例如 2015-08.
     */
    private static final String MONTH_PATTERN = "yyyy-MM";

    /**
     * 仅显示年月(无符号),例如 201508.
     */
    private static final String UNSIGNED_MONTH_PATTERN = "yyyyMM";

    /**
     * 一天的开始时间,仅显示时分秒
     */
    private static final String START_TIME = "00:00:00";

    /**
     * 一天的结束时间,仅显示时分秒
     */
    private static final String END_TIME = "23:59:59";

    /**
     * 每天的毫秒数.
     */
    public static final long MILLISECONDS_PER_DAY = 86400000L;

    /**
     * 每小时毫秒数.
     */
    public static final long MILLISECONDS_PER_HOUR = 3600000L;

    /**
     * 每分钟毫秒数.
     */
    public static final long MILLISECONDS_PER_MINU = 60000L;

    /**
     * 每秒的毫秒数.
     */
    public static final long MILLISECONDS_PER_SECONDS = 1000L;

    /**
     * 每分钟秒数.
     */
    public static final long SECONDS_PER_MINUTE = 60L;

    /**
     * 每小时秒数.
     */
    public static final long SECONDS_PER_HOUR = 3600L;

    /**
     * 每天秒数.
     */
    public static final long SECONDS_PER_DAY = 86400L;

    /**
     * 每周秒数.
     */
    public static final long SECONDS_PER_WEEK = 604800L;

    /**
     * 每个月秒数,默认每月30天.
     */
    public static final long SECONDS_PER_MONTH = 2592000L;

    /**
     * 每年秒数,默认每年365天.
     */
    public static final long SECONDS_PER_YEAR = 31536000L;

    /**
     * 每周的天数.
     */
    public static final long DAYS_PER_WEEK = 7L;

    /**
     * 春天;
     */
    public static final Integer SPRING = 1;

    /**
     * 夏天;
     */
    public static final Integer SUMMER = 2;

    /**
     * 秋天;
     */
    public static final Integer AUTUMN = 3;

    /**
     * 冬天;
     */
    public static final Integer WINTER = 4;

    /**
     * 星期日;
     */
    public static final String SUNDAY = "星期日";

    /**
     * 星期一;
     */
    public static final String MONDAY = "星期一";

    /**
     * 星期二;
     */
    public static final String TUESDAY = "星期二";

    /**
     * 星期三;
     */
    public static final String WEDNESDAY = "星期三";

    /**
     * 星期四;
     */
    public static final String THURSDAY = "星期四";

    /**
     * 星期五;
     */
    public static final String FRIDAY = "星期五";

    /**
     * 星期六;
     */
    public static final String SATURDAY = "星期六";

    /**
     * 获取当前日期和时间字符串.
     *
     * @return String 日期时间字符串,例如 2015-08-11 09:51:53
     */
    public static String getDateTimeStr() {
        return format(new Date(), DATETIME_PATTERN);
    }

    /**
     * 获取当前日期字符串.
     *
     * @return String 日期字符串,例如2015-08-11
     */
    public static String getDateStr() {
        return format(new Date(), DATE_PATTERN);
    }

    /**
     * 获取当前时间字符串.
     *
     * @return String 时间字符串,例如 09:51:53
     */
    public static String getTimeStr() {
        return format(new Date(), TIME_PATTERN);
    }

    /**
     * 获取当前年份字符串.
     *
     * @return String 当前年份字符串,例如 2015
     */
    public static String getYearStr() {
        return format(new Date(), YEAR_PATTERN);
    }

    /**
     * 获取当前月份字符串.
     *
     * @return String 当前月份字符串,例如 08
     */
    public static String getMonthStr() {
        return format(new Date(), "MM");
    }

    /**
     * 获取当前天数字符串.
     *
     * @return String 当前天数字符串,例如 11
     */
    public static String getDayStr() {
        return format(new Date(), "dd");
    }

    /**
     * 获取当前星期字符串.
     *
     * @return String 当前星期字符串,例如 星期二
     */
    public static String getDayOfWeekStr() {
        return format(new Date(), "E");
    }

    /**
     * 获取指定日期是星期几
     *
     * @param date 日期
     * @return String 星期几
     */
    public static String getDayOfWeekStr(Date date) {
        String[] weekOfDays = {SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY};
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int num = calendar.get(Calendar.DAY_OF_WEEK) - 1;
        return weekOfDays[num];
    }

    /**
     * 获取当前小时字符串.
     *
     * @return String 当前小时字符串,例如09
     */
    public static String getHourStr() {
        return format(new Date(), "HH");
    }

    /**
     * 获取当前分钟字符串.
     *
     * @return String 当前分钟字符串,例如51
     */
    public static String getMinuteStr() {
        return format(new Date(), "mm");
    }

    /**
     * 获取当前秒钟字符串.
     *
     * @return String 当前秒钟字符串,例如53
     */
    public static String getSecondStr() {
        return format(new Date(), "ss");
    }

    /**
     * 获取日期时间字符串
     *
     * @param date    需要转化的日期时间
     * @param pattern 时间格式
     * @return String 日期时间字符串,例如 2015-08-11 09:51:53
     */
    public static String format(Date date, String pattern) {
        return new SimpleDateFormat(pattern).format(date);
    }

    /**
     * 时间戳转换为日期时间字符串
     *
     * @param timestamp 时间戳
     * @param pattern   日期格式 例如DATETIME_PATTERN
     * @return String 日期时间字符串,例如 2015-08-11 09:51:53
     */
    public static String getDateTimeStr(long timestamp, String pattern) {
        return new SimpleDateFormat(pattern).format(timestamp);
    }

    /**
     * 日期字符串转换为日期(java.util.Date)
     *
     * @param dateStr 日期字符串
     * @param pattern 日期格式 例如DATETIME_PATTERN
     * @return Date 日期
     */
    public static Date parse(String dateStr, String pattern) {
        Date date = null;
        SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
        // 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期,比如2007/02/29会被接受,并转换成2007/03/01
        dateFormat.setLenient(false);
        try {
            date = dateFormat.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 获取指定日期num年数之后的日期.
     *
     * @param num 间隔年数(负数表示之前)
     * @return Date 日期
     */
    public static Date addYears(Date date, int num) {
        return add(date, num, Calendar.YEAR);
    }

    /**
     * 获取当前日期指定年数之后的日期.
     *
     * @param num 间隔年数(负数表示之前)
     * @return Date 日期
     */
    public static Date addYears(int num) {
        return add(new Date(), num, Calendar.YEAR);
    }

    /**
     * 获取当前日期num月数之后的日期.
     *
     * @param num 间隔月数(负数表示之前)
     * @return Date 日期
     */
    public static Date addMonths(Date date, int num) {
        return add(date, num, Calendar.MONTH);
    }

    /**
     * 获取当前日期指定月数之后的日期.
     *
     * @param num 间隔月数(负数表示之前)
     * @return Date 日期
     */
    public static Date addMonths(int num) {
        return add(new Date(), num, Calendar.MONTH);
    }

    /**
     * 获取指定日期num周数之后的日期.
     *
     * @param date 日期
     * @param num  周数(负数表示之前)
     * @return Date 新的日期
     */
    public static Date addWeeks(Date date, int num) {
        return add(date, num, Calendar.WEEK_OF_YEAR);
    }

    /**
     * 获取当前日期指定周数之后的日期.
     *
     * @param num 周数(负数表示之前)
     * @return Date 新的日期
     */
    public static Date addWeeks(int num) {
        return add(new Date(), num, Calendar.WEEK_OF_YEAR);
    }

    /**
     * 获取指定日期num天数之后的日期.
     *
     * @param date 日期
     * @param num  天数(负数表示之前)
     * @return Date 新的日期
     */
    public static Date addDays(Date date, int num) {
        return add(date, num, Calendar.DAY_OF_MONTH);
    }

    /**
     * 获取当前日期指定天数之后的日期.
     *
     * @param num 天数(负数表示之前)
     * @return Date 新的日期
     */
    public static Date addDays(int num) {
        return add(new Date(), num, Calendar.DAY_OF_MONTH);
    }

    /**
     * 获取指定日期num小时之后的日期.
     *
     * @param date 日期
     * @param num  小时数(负数表示之前)
     * @return Date 新的日期
     */
    public static Date addHours(Date date, int num) {
        return add(date, num, Calendar.HOUR_OF_DAY);
    }

    /**
     * 获取当前日期指定小时之后的日期.
     *
     * @param num 小时数(负数表示之前)
     * @return Date 新的日期
     */
    public static Date addHours(int num) {
        return add(new Date(), num, Calendar.HOUR_OF_DAY);
    }

    /**
     * 获取指定日期num分钟之后的日期.
     *
     * @param date 日期
     * @param num  分钟数(负数表示之前)
     * @return Date 新的日期
     */
    public static Date addMinutes(Date date, int num) {
        return add(date, num, Calendar.MINUTE);
    }

    /**
     * 获取当前日期指定分钟之后的日期.
     *
     * @param num 分钟数(负数表示之前)
     * @return Date 新的日期
     */
    public static Date addMinutes(int num) {
        return add(new Date(), num, Calendar.MINUTE);
    }

    /**
     * 获取指定日期num秒钟之后的日期.
     *
     * @param date 日期
     * @param num  秒钟数(负数表示之前)
     * @return Date 新的日期
     */
    public static Date addSeconds(Date date, int num) {
        return add(date, num, Calendar.SECOND);
    }

    /**
     * 获取当前日期指定秒钟之后的日期.
     *
     * @param num 秒钟数(负数表示之前)
     * @return Date 新的日期
     */
    public static Date addSeconds(int num) {
        return add(new Date(), num, Calendar.SECOND);
    }

    /**
     * 获取指定日期num毫秒之后的日期.
     *
     * @param date 日期
     * @param num  毫秒数(负数表示之前)
     * @return Date 新的日期
     */
    public static Date addMilliSeconds(Date date, int num) {
        return add(date, num, Calendar.MILLISECOND);
    }

    /**
     * 获取当前日期指定毫秒之后的日期.
     *
     * @param num 毫秒数(负数表示之前)
     * @return Date 新的日期
     */
    public static Date addMilliSeconds(int num) {
        return add(new Date(), num, Calendar.MILLISECOND);
    }

    /**
     * 获取当前日期指定数量日期时间单位之后的日期.
     *
     * @param date 日期
     * @param num  数量
     * @param unit 日期时间单位
     * @return Date 新的日期
     */
    public static Date add(Date date, int num, int unit) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(unit, num);
        return calendar.getTime();
    }

    /**
     * 计算两个日期之间相隔年数.
     *
     * @param startDate 开始日期
     * @param endDate   结束日期
     * @return int 相隔年数,向下取整
     */
    public static int getYearsBetween(Date startDate, Date endDate) {
        return getMonthsBetween(startDate, endDate) / 12;
    }

    /**
     * 计算两个日期之间相隔月数.
     *
     * @param startDate 开始日期
     * @param endDate   结束日期
     * @return int 相隔月数,向下取整
     */
    public static int getMonthsBetween(Date startDate, Date endDate) {
        int months;
        int flag = 0;

        Calendar startCalendar = Calendar.getInstance();
        startCalendar.setTime(startDate);
        Calendar endCalendar = Calendar.getInstance();
        endCalendar.setTime(endDate);

        if (endCalendar.equals(startCalendar)) {
            return 0;
        }

        if (startCalendar.after(endCalendar)) {
            Calendar temp = startCalendar;
            startCalendar = endCalendar;
            endCalendar = temp;
        }
        if (endCalendar.get(Calendar.DAY_OF_MONTH) < startCalendar.get(Calendar.DAY_OF_MONTH)) {
            flag = 1;
        }

        if (endCalendar.get(Calendar.YEAR) > startCalendar.get(Calendar.YEAR)) {
            months = ((endCalendar.get(Calendar.YEAR) - startCalendar.get(Calendar.YEAR))
                    * 12 + endCalendar.get(Calendar.MONTH) - flag)
                    - startCalendar.get(Calendar.MONTH);
        } else {
            months = endCalendar.get(Calendar.MONTH)
                    - startCalendar.get(Calendar.MONTH) - flag;
        }

        return months;
    }

    /**
     * 计算两个日期之间相隔周数.
     *
     * @param startDate 开始日期
     * @param endDate   结束日期
     * @return long 相隔周数,向下取整
     */
    public static long getWeeksBetween(Date startDate, Date endDate) {
        return getDaysBetween(startDate, endDate) / DAYS_PER_WEEK;
    }

    /**
     * 计算两个日期之间相隔天数.
     *
     * @param startDate 开始日期
     * @param endDate   结束日期
     * @return long 相隔天数,向下取整
     */
    public static long getDaysBetween(Date startDate, Date endDate) {
        return (endDate.getTime() - startDate.getTime()) / MILLISECONDS_PER_DAY;
    }

    /**
     * 计算两个日期之间相隔小时数.
     *
     * @param startDate 开始日期
     * @param endDate   结束日期
     * @return long 相隔小时数,向下取整
     */
    public static long getHoursBetween(Date startDate, Date endDate) {
        return (endDate.getTime() - startDate.getTime()) / MILLISECONDS_PER_HOUR;
    }

    /**
     * 计算两个日期之间相隔分钟数.
     *
     * @param startDate 开始日期
     * @param endDate   结束日期
     * @return long 相隔分钟数,向下取整
     */
    public static long getMinutesBetween(Date startDate, Date endDate) {
        return (endDate.getTime() - startDate.getTime()) / MILLISECONDS_PER_MINU;
    }

    /**
     * 计算两个日期之间相隔秒数.
     *
     * @param startDate 开始日期
     * @param endDate   结束日期
     * @return long 相隔秒数,向下取整
     */
    public static long getSecondsBetween(Date startDate, Date endDate) {
        return (endDate.getTime() - startDate.getTime()) / MILLISECONDS_PER_SECONDS;
    }

    /**
     * 获取当前季度.
     * 注意:3~5月为春季 1,6~8月为夏季 2,9~11月为秋季 3,12~2月为冬季 4
     *
     * @return int 当前季度数
     */
    public static int getCurrentSeason() {
        Calendar calendar = Calendar.getInstance();
        int month = calendar.get(Calendar.MONTH) + 1;
        int season = 0;
        if (month >= 3 && month <= 5) {
            season = SPRING;
        } else if (month >= 6 && month <= 8) {
            season = SUMMER;
        } else if (month >= 9 && month <= 11) {
            season = AUTUMN;
        } else if (month == 12 || month >= 1 && month <= 2) {
            season = WINTER;
        }
        return season;
    }

    /**
     * 获取当前日期与之前日期的时间间隔.
     *
     * @param date 之前的日期
     * @return String 例如 16分钟前、2小时前、3天前、4月前、5年前等
     */
    public static String getIntervalByDate(Date date) {
        long secondsBetween = getSecondsBetween(date, new Date());
        return getIntervalBySeconds(secondsBetween);
    }

    /**
     * 将以秒为单位的时间转换为其他单位.
     *
     * @param seconds 秒数
     * @return String 例如 16分钟前、2小时前、3天前、4月前、5年前等
     */
    public static String getIntervalBySeconds(long seconds) {
        StringBuffer buffer = new StringBuffer();
        if (seconds < SECONDS_PER_MINUTE) {
            buffer.append(seconds).append("秒前");
        } else if (seconds < SECONDS_PER_HOUR) {
            buffer.append((long) Math.floor(seconds / SECONDS_PER_MINUTE)).append("分钟前");
        } else if (seconds < SECONDS_PER_DAY) {
            buffer.append((long) Math.floor(seconds / SECONDS_PER_HOUR)).append("小时前");
        } else if (seconds < SECONDS_PER_WEEK) {
            buffer.append((long) Math.floor(seconds / SECONDS_PER_DAY)).append("天前");
        } else if (seconds < SECONDS_PER_MONTH) {
            buffer.append((long) Math.floor(seconds / SECONDS_PER_WEEK)).append("周前");
        } else if (seconds < SECONDS_PER_YEAR) {
            buffer.append((long) Math.floor(seconds / SECONDS_PER_MONTH)).append("月前");
        } else {
            buffer.append((long) Math.floor(seconds / SECONDS_PER_YEAR)).append("年前");
        }
        return buffer.toString();
    }

    /**
     * 将 Date 日期转化为 Calendar 类型日期.
     *
     * @param date 指定日期
     * @return Calendar Calendar对象
     */
    public static Calendar getCalendar(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar;
    }

    /**
     * 得到UTC时间,类型为字符串,格式为"yyyy-MM-dd HH:mm"
     * 如果获取失败,返回null
     *
     * @return
     */
    public static String getUTCTimeStr() {
        StringBuffer UTCTimeBuffer = new StringBuffer();
        // 1、取得本地时间:
        Calendar cal = Calendar.getInstance();
        // 2、取得时间偏移量:
        int zoneOffset = cal.get(Calendar.ZONE_OFFSET);
        // 3、取得夏令时差:
        int dstOffset = cal.get(Calendar.DST_OFFSET);
        // 4、从本地时间里扣除这些差量,即可以取得UTC时间:
        cal.add(Calendar.MILLISECOND, -(zoneOffset + dstOffset));
        int year = cal.get(Calendar.YEAR);
        int month = cal.get(Calendar.MONTH) + 1;
        int day = cal.get(Calendar.DAY_OF_MONTH);
        int hour = cal.get(Calendar.HOUR_OF_DAY);
        int minute = cal.get(Calendar.MINUTE);
        UTCTimeBuffer.append(year).append("-").append(month).append("-").append(day);
        UTCTimeBuffer.append(" ").append(hour).append(":").append(minute);
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(NO_SECOND_DATETIME_PATTERN);
            sdf.parse(UTCTimeBuffer.toString());
            return UTCTimeBuffer.toString();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 将Timestamp转换为yyyy-MM-dd HH:mm:ss格式字符串
     *
     * @param timestamp
     * @return
     */
    public static String timestampToStr(Timestamp timestamp) {
        return timestamp.toString().substring(0, 19);
    }

    /**
     * 比较传进来的日期是否大于当前日期,如果传进来的日期大于当前日期则返回true,否则返回false
     *
     * @param dateStr 日期字符串
     * @param pattern 日期格式
     * @return boolean
     */
    public static boolean compareNowDate(String dateStr, String pattern) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
        try {
            Date date = simpleDateFormat.parse(dateStr);
            return date.after(new Date());
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 如果endDateStr>startDateStr,返回true,否则返回false
     *
     * @param startDateStr 开始日期字符串
     * @param endDateStr   结束日期字符串
     * @param pattern      日期格式
     * @return boolean
     */
    public static boolean compareDate(String startDateStr, String endDateStr, String pattern) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
        try {
            Date startDate = simpleDateFormat.parse(startDateStr);
            Date endDate = simpleDateFormat.parse(endDateStr);
            return endDate.after(startDate);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 如果startDate>endDate,返回true,否则返回false
     *
     * @param startDate 开始日期字符串
     * @param endDate   结束日期字符串
     * @return boolean
     */
    public static boolean compareDate(Date startDate, Date endDate) {
        return endDate.after(startDate);
    }

    /**
     * 判断日期是否合法
     *
     * @param dateStr yyyy-MM-dd HH:mm:ss格式日期字符串
     * @return
     */
    public static boolean isValidDate(String dateStr) {
        boolean convertSuccess = true;
        // 指定日期格式为四位年/两位月份/两位日期
        SimpleDateFormat format = new SimpleDateFormat(DATETIME_PATTERN);
        try {
            // 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期,比如2007/02/29会被接受,并转换成2007/03/01
            format.setLenient(false);
            format.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
            // 如果throw java.text.ParseException或者NullPointerException,就说明格式不对
            convertSuccess = false;
        }
        return convertSuccess;
    }

    /**
     * 判断日期是否为月底最后一天
     *
     * @param date 日期
     * @return boolean true:是  false:否
     */
    public static boolean isLastDayofMonth(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.DATE, (calendar.get(Calendar.DATE) + 1));
        if (calendar.get(Calendar.DAY_OF_MONTH) == 1) {
            return true;
        }
        return false;
    }

    /**
     * 获取本年第一天的日期字符串
     *
     * @return String 格式:yyyy-MM-dd HH:mm:ss
     */
    public static String getYearStartTimeStr() {
        return getDateTimeStr(getStartDayOfYear(new Date()));
    }

    /**
     * 获取指定日期当年第一天的日期字符串
     *
     * @param date
     * @return String 格式:yyyy-MM-dd HH:mm:ss
     */
    public static String getYearStartTimeStr(Date date) {
        return getDateTimeStr(getStartDayOfYear(date));
    }

    /**
     * 获取本年最后一天的日期字符串
     *
     * @return String 格式:yyyy-MM-dd HH:mm:ss
     */
    public static String getYearEndTimeStr() {
        return getDateTimeStr(getEndDayOfYear(new Date()));
    }

    /**
     * 获取指定日期当年最后一天的日期字符串
     *
     * @param date 指定日期
     * @return String 格式:yyyy-MM-dd HH:mm:ss
     */
    public static String getYearEndTimeStr(Date date) {
        return getDateTimeStr(getEndDayOfYear(date));
    }

    /**
     * 获取本月第一天的日期字符串
     * 格式:yyyy-MM-dd HH:mm:ss
     *
     * @return
     */
    public static String getMonthStartTimeStr() {
        return getDateTimeStr(getStartDayOfMonth(new Date()));
    }

    /**
     * 获取指定日期当月第一天的日期字符串
     *
     * @param date 指定日期
     * @return String 格式:yyyy-MM-dd HH:mm:ss
     */
    public static String getMonthStartTimeStr(Date date) {
        return getDateTimeStr(getStartDayOfMonth(date));
    }

    /**
     * 获取本月最后一天的日期字符串
     *
     * @return String 格式:yyyy-MM-dd HH:mm:ss
     */
    public static String getMonthEndTimeStr() {
        return getDateTimeStr(getEndDayOfMonth(new Date()));
    }

    /**
     * 获取指定日期当月最后一天的日期字符串
     *
     * @param date 指定日期
     * @return String 格式:yyyy-MM-dd HH:mm:ss
     */
    public static String getMonthEndTimeStr(Date date) {
        return getDateTimeStr(getEndDayOfMonth(date));
    }

    /**
     * 获取本周第一天的日期字符串
     *
     * @return String 格式:yyyy-MM-dd HH:mm:ss
     */
    public static String getWeekStartTimeStr() {
        return getDateTimeStr(getStartDayOfWeek(new Date()));
    }

    /**
     * 获取指定日期当周第一天的日期字符串
     *
     * @param date 指定日期
     * @return String 格式:yyyy-MM-dd HH:mm:ss
     */
    public static String getWeekStartTimeStr(Date date) {
        return getDateTimeStr(getStartDayOfWeek(date));
    }

    /**
     * 获取本周最后一天的日期字符串
     *
     * @return String 格式:yyyy-MM-dd HH:mm:ss
     */
    public static String getWeekEndTimeStr() {
        return getDateTimeStr(getEndDayOfWeek(new Date()));
    }

    /**
     * 获取指定日期当周最后一天的日期字符串
     *
     * @param date 指定日期
     * @return String 格式:yyyy-MM-dd HH:mm:ss
     */
    public static String getWeekEndTimeStr(Date date) {
        return getDateTimeStr(getEndDayOfWeek(date));
    }

    /**
     * 获取今天的开始时间字符串
     *
     * @return String 格式:yyyy-MM-dd HH:mm:ss
     */
    public static String getTodayStartTimeStr() {
        return getDateTimeStr(getTodayStartTime(new Date()));
    }

    /**
     * 获取指定日期的开始时间字符串
     *
     * @param date 指定日期
     * @return String 格式:yyyy-MM-dd HH:mm:ss
     */
    public static String getTodayStartTimeStr(Date date) {
        return getDateTimeStr(getTodayStartTime(date));
    }

    /**
     * 获取今天的结束时间字符串
     *
     * @return String 格式:yyyy-MM-dd HH:mm:ss
     */
    public static String getTodayEndTimeStr() {
        return getDateTimeStr(getTodayEndTime(new Date()));
    }

    /**
     * 获取指定日期的结束时间字符串
     *
     * @param date 指定日期
     * @return String 格式:yyyy-MM-dd HH:mm:ss
     */
    public static String getTodayEndTimeStr(Date date) {
        return getDateTimeStr(getTodayEndTime(date));
    }

    /**
     * 获得指定日期所在日的开始时间字符串
     *
     * @param date 指定日期
     * @return String 例如:2020-12-06 00:00:00
     */
    public static String getDateStartTimeStr(Date date) {
        String result = format(date, DATE_PATTERN);
        return result.concat(" ").concat(START_TIME);
    }

    /**
     * 获得指定日期所在日的结束时间字符串
     *
     * @param date 指定日期
     * @return String 例如:2020-12-06 23:59:59
     */
    public static String getDateEndTimeStr(Date date) {
        String result = format(date, DATE_PATTERN);
        return result.concat(" ").concat(END_TIME);
    }

    /**
     * 根据日历返回日期时间字符串
     *
     * @param calendar 日历
     * @return String 日期时间字符串
     */
    public static String getDateTimeStr(Calendar calendar) {
        StringBuffer buf = new StringBuffer("");

        buf.append(calendar.get(Calendar.YEAR));
        buf.append("-");
        buf.append(calendar.get(Calendar.MONTH) + 1 > 9 ? calendar.get(Calendar.MONTH) + 1 + ""
                : "0" + (calendar.get(Calendar.MONTH) + 1));
        buf.append("-");
        buf.append(calendar.get(Calendar.DAY_OF_MONTH) > 9 ? calendar.get(Calendar.DAY_OF_MONTH) + ""
                : "0" + calendar.get(Calendar.DAY_OF_MONTH));
        buf.append(" ");
        buf.append(calendar.get(Calendar.HOUR_OF_DAY) > 9 ? calendar.get(Calendar.HOUR_OF_DAY) + ""
                : "0" + calendar.get(Calendar.HOUR_OF_DAY));
        buf.append(":");
        buf.append(calendar.get(Calendar.MINUTE) > 9 ? calendar.get(Calendar.MINUTE) + ""
                : "0" + calendar.get(Calendar.MINUTE));
        buf.append(":");
        buf.append(calendar.get(Calendar.SECOND) > 9 ? calendar.get(Calendar.SECOND) + ""
                : "0" + calendar.get(Calendar.SECOND));
        return buf.toString();
    }

    /**
     * 获取今年的第一天
     *
     * @return Calendar 日历
     */
    public static Calendar getStartDayOfYear(Date date) {
        Calendar calendar = Calendar.getInstance(Locale.CHINA);
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_YEAR, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        return calendar;
    }

    /**
     * 获取今年的最后一天
     *
     * @return Calendar 日历
     */
    public static Calendar getEndDayOfYear(Date date) {
        Calendar calendar = Calendar.getInstance(Locale.CHINA);
        calendar.setTime(date);
        int i = calendar.getActualMaximum(Calendar.DAY_OF_YEAR);
        calendar.set(Calendar.DAY_OF_YEAR, i);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        return calendar;
    }

    /**
     * 获取本月的第一天
     *
     * @return Calendar 日历
     */
    public static Calendar getStartDayOfMonth(Date date) {
        Calendar calendar = Calendar.getInstance(Locale.CHINA);
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        return calendar;
    }

    /**
     * 获取本月的最后一天
     *
     * @return Calendar 日历
     */
    public static Calendar getEndDayOfMonth(Date date) {
        Calendar calendar = Calendar.getInstance(Locale.CHINA);
        calendar.setTime(date);
        int i = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        calendar.set(Calendar.DAY_OF_MONTH, i);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        return calendar;
    }

    /**
     * 获取本周的第一天,一个星期的第一天是星期一,最后一天是星期天
     *
     * @return Calendar 日历
     */
    public static Calendar getStartDayOfWeek(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        // 设置一个星期的第一天,按中国的习惯一个星期的第一天是星期一
        calendar.setFirstDayOfWeek(Calendar.MONDAY);
        calendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);

        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        return calendar;
    }

    /**
     * 获取本周的最后一天,一个星期的第一天是星期一,最后一天是星期天
     *
     * @return Calendar 日历
     */
    public static Calendar getEndDayOfWeek(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        // 设置一个星期的第一天,按中国的习惯一个星期的第一天是星期一
        calendar.setFirstDayOfWeek(Calendar.MONDAY);
        calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);

        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        return calendar;
    }

    /**
     * 获取今天开始时间
     *
     * @return
     */
    public static Calendar getTodayStartTime(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar;
    }

    /**
     * 获取今天结束时间
     *
     * @return
     */
    public static Calendar getTodayEndTime(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 999);
        return calendar;
    }

    /**
     * 根据日期范围,获取按周期划分的日期区间
     *
     * @param startDateStr 开始日期(格式:2020-11-29)
     * @param endDateStr   结束日期(格式:2020-12-02)
     * @param pattern      日期格式(支持:DATE_PATTERN,MONTH_PATTERN,YEAR_PATTERN)
     * @return List<String> 区间集合 例如:[2020-11-29,2020-11-30,2020-12-01,2020-12-02]
     */
    public static List<String> getDateStrList(String startDateStr, String endDateStr, String pattern) {
        Date start = parse(startDateStr, pattern);
        Date end = parse(endDateStr, pattern);
        return getDateStrList(start, end, pattern);
    }

    /**
     * 根据日期范围,获取按周期划分的日期区间
     *
     * @param startDate 开始日期
     * @param endDate   结束日期
     * @param pattern   日期格式(支持:DATE_PATTERN,MONTH_PATTERN,YEAR_PATTERN)
     * @return List<String> 区间集合 例如:[2020-11-29,2020-11-30,2020-12-01,2020-12-02]
     */
    public static List<String> getDateStrList(Date startDate, Date endDate, String pattern) {
        List<String> result = new ArrayList<>();

        Calendar calendar = Calendar.getInstance();
        calendar.setTime(startDate);
        if (DATE_PATTERN.equals(pattern)) {
            while (startDate.before(endDate) || startDate.equals(endDate)) {
                result.add(new SimpleDateFormat(DATE_PATTERN).format(calendar.getTimeInMillis()));
                calendar.add(Calendar.DATE, 1);
                startDate = calendar.getTime();
            }
        } else if (MONTH_PATTERN.equals(pattern)) {
            while (startDate.before(endDate) || startDate.equals(endDate)) {
                result.add(new SimpleDateFormat(MONTH_PATTERN).format(calendar.getTimeInMillis()));
                calendar.add(Calendar.MONTH, 1);
                startDate = calendar.getTime();
            }
        } else if (YEAR_PATTERN.equals(pattern)) {
            while (startDate.before(endDate) || startDate.equals(endDate)) {
                result.add(new SimpleDateFormat(YEAR_PATTERN).format(calendar.getTimeInMillis()));
                calendar.add(Calendar.YEAR, 1);
                startDate = calendar.getTime();
            }
        }
        return result;
    }

    /**
     * 获取当前日期前后num天的集合
     *
     * @param num 天数(正数:之后;负数:之前)
     * @return List<String> 前/后日期的集合(包含指定日期)
     */
    public static List<String> getDateStrList(int num) {
        return getDateStrList(new Date(), num, DATE_PATTERN);
    }

    /**
     * 获取指定日期前后num天的集合
     *
     * @param date 指定日期
     * @param num  天数(正数:之后;负数:之前)
     * @return List<String> 前/后日期的集合(包含指定日期)
     */
    public static List<String> getDateStrList(Date date, int num) {
        return getDateStrList(date, num, DATE_PATTERN);
    }

    /**
     * 获取指定日期前后num天的集合,带日期格式参数
     *
     * @param date    指定日期
     * @param num     天数(正数:之后;负数:之前)
     * @param pattern 日期格式
     * @return List<String> 前/后日期的集合(包含指定日期)  例如:[2020-11-29,2020-11-30,2020-12-01]
     */
    public static List<String> getDateStrList(Date date, int num, String pattern) {
        List<String> result = new ArrayList<>();
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        boolean flag = false;
        if (num < 0) {
            num = Math.abs(num);
            flag = true;
        }
        for (int i = 0; i < num; i++) {
            result.add(new SimpleDateFormat(pattern).format(c.getTimeInMillis()));
            c.add(Calendar.DATE, flag ? -1 : 1);
        }
        if (flag) {
            Collections.reverse(result);
        }
        return result;
    }

    public static void main(String[] args) {
        System.out.println("=======================");
        System.out.println(getYearStr());
        System.out.println(getMonthStr());
        System.out.println(getDayStr());
        System.out.println(getHourStr());
        System.out.println(getMinuteStr());
        System.out.println(getSecondStr());

        System.out.println(getDateTimeStr());
        System.out.println(getDateStr());
        System.out.println(getTimeStr());
        System.out.println(getDayOfWeekStr());
        System.out.println(getDayOfWeekStr(parse("2020-12-05", DATE_PATTERN)));
        System.out.println(getDateTimeStr(System.currentTimeMillis(), DATETIME_PATTERN));

        System.out.println("=======================");
        System.out.println(parse("2020-12-31", DATE_PATTERN));

        System.out.println("=======================");
        System.out.println(addYears(1));
        System.out.println(addYears(new Date(), -1));
        System.out.println(addMonths(1));
        System.out.println(addMonths(new Date(), -1));
        System.out.println(addWeeks(1));
        System.out.println(addWeeks(new Date(), -1));
        System.out.println(addDays(1));
        System.out.println(addDays(new Date(), -1));
        System.out.println(addHours(1));
        System.out.println(addHours(new Date(), -1));
        System.out.println(addMinutes(1));
        System.out.println(addMinutes(new Date(), -1));
        System.out.println(addSeconds(1));
        System.out.println(addSeconds(new Date(), -1));
        System.out.println(addMilliSeconds(1));
        System.out.println(addMilliSeconds(new Date(), -1));

        System.out.println("=======================");
        System.out.println(getYearsBetween(parse("2020-01-30", DATE_PATTERN), parse("2021-01-29", DATE_PATTERN)));
        System.out.println(getMonthsBetween(parse("2020-01-30", DATE_PATTERN), parse("2021-01-29", DATE_PATTERN)));
        System.out.println(getWeeksBetween(parse("2020-01-30", DATE_PATTERN), parse("2020-02-06", DATE_PATTERN)));
        System.out.println(getDaysBetween(parse("2020-01-30", DATE_PATTERN), parse("2020-02-06", DATE_PATTERN)));
        System.out.println(getHoursBetween(parse("2020-01-30", DATE_PATTERN), parse("2020-02-06", DATE_PATTERN)));
        System.out.println(getMinutesBetween(parse("2020-01-30", DATE_PATTERN), parse("2020-02-06", DATE_PATTERN)));
        System.out.println(getSecondsBetween(parse("2020-12-06 19:47:00", DATETIME_PATTERN), parse("2020-12-06 19:47:50", DATETIME_PATTERN)));

        System.out.println("=======================");
        System.out.println(getCurrentSeason());

        System.out.println("=======================");
        System.out.println(getIntervalByDate(parse("2020-12-06 19:30:00", DATETIME_PATTERN)));
        System.out.println(getIntervalBySeconds(604800L));

        System.out.println("=======================");
        System.out.println(getCalendar(new Date()));
        System.out.println(getUTCTimeStr());

        System.out.println("=======================");
        System.out.println(timestampToStr(new Timestamp(System.currentTimeMillis())));

        System.out.println("=======================");
        System.out.println(compareNowDate("2020-12-07", DATE_PATTERN));
        System.out.println(compareDate(parse("2020-12-05", DATE_PATTERN), new Date()));
        System.out.println(compareDate("2020-12-05", "2020-12-06", DATE_PATTERN));

        System.out.println("=======================");
        System.out.println(isValidDate("2020-02-29 23:59:00"));
        System.out.println(isLastDayofMonth(parse("2020-11-01 00:00:00", DATETIME_PATTERN)));

        System.out.println("=======================");
        System.out.println(getYearStartTimeStr());
        System.out.println(getYearStartTimeStr(parse("2019-12-06", DATE_PATTERN)));
        System.out.println(getYearEndTimeStr());
        System.out.println(getYearEndTimeStr(parse("2019-12-06", DATE_PATTERN)));
        System.out.println(getMonthStartTimeStr());
        System.out.println(getMonthStartTimeStr(parse("2019-12-06", DATE_PATTERN)));
        System.out.println(getMonthEndTimeStr());
        System.out.println(getMonthEndTimeStr(parse("2019-12-06", DATE_PATTERN)));
        System.out.println(getWeekStartTimeStr());
        System.out.println(getWeekStartTimeStr(parse("2019-12-06", DATE_PATTERN)));
        System.out.println(getWeekEndTimeStr());
        System.out.println(getWeekEndTimeStr(parse("2019-12-06", DATE_PATTERN)));
        System.out.println(getTodayStartTimeStr());
        System.out.println(getTodayStartTimeStr(parse("2019-12-06", DATE_PATTERN)));
        System.out.println(getTodayEndTimeStr());
        System.out.println(getTodayEndTimeStr(parse("2019-12-06", DATE_PATTERN)));
        System.out.println(getDateStartTimeStr(parse("2020-11-01 00:00:00", DATETIME_PATTERN)));
        System.out.println(getDateEndTimeStr(parse("2020-11-01 00:00:00", DATETIME_PATTERN)));

        System.out.println("=======================");
        List<String> strList1 = getDateStrList(3);
        for (String s : strList1) {
            System.out.println(s);
        }

        System.out.println("=======================");
        List<String> dayList = getDateStrList(parse("2020-11-29", DATE_PATTERN), 3);
        for (String s : dayList) {
            System.out.println(s);
        }

        System.out.println("=======================");
        List<String> dateList = getDateStrList("2020-11-29", "2020-12-06", DATE_PATTERN);
        for (String s : dateList) {
            System.out.println(s);
        }

        System.out.println("=======================");
        List<String> strList = getDateStrList(parse("2020-11-29", DATE_PATTERN), parse("2020-12-06", DATE_PATTERN), DATE_PATTERN);
        for (String s : strList) {
            System.out.println(s);
        }
    }

}
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页