封装date工具类

写代码的过程中肯定会用到很多获取时间，转换时间为字符串或者字符串转换时间的小场景，但我一般直接在代码中直接new SimpleDateFormat。。。这样是很不方便的，可以在创建一个common包，或者Util包，在包下创建个date包，在此包下创建一个工具类，使用的时候直接通过类名点方法名

package com.test.hello.common.date;

import com.google.common.base.Strings;
import com.google.common.collect.Sets;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;

import java.util.Calendar;
import java.util.Date;
import java.util.Set;
import java.util.regex.Pattern;

public class Dates {

    private static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
    private static final String DEFAULT_DATE_FORMAT2 = "yyyyMMddHHmmss";
    private static final String DEFAULT_DATE_FORMAT3 = "yyyyMMdd";

    /**
     * 简单的日期格式校验(yyyy-MM-dd)
     * @param date 输入日期
     * @return 有效返回true, 反之false
     */
    public static Boolean isValidDate(String date){
        return isValidDate(date, "\\d{4}-\\d{2}-\\d{2}");
    }

    /**
     * 简单的日期格式校验(yyyy-MM-dd)
     * @param date 输入日期
     * @return 有效返回true, 反之false
     */
    public static Boolean isValidDate(String date, String pattern){
        return !Strings.isNullOrEmpty(date)
                && Pattern.compile(pattern).matcher(date).matches();
    }

    /**
     * 获取当前日期对象
     * @return 当前日期对象
     */
    public static Date now(){
        return new Date();
    }

    /**
     * 获取当前日期字符串
     * @param format 日期格式
     * @return 当前日期字符串
     */
    public static String now(String format){
        return format(now(), format);
    }

    /**
     * 转换日期字符串为日期对象
     * @param dateStr 日期字符串
     * @return 日期对象
     */
    public static Date toDate(String dateStr){
        return toDate(dateStr, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 转换日期字符串为日期对象
     * @param dateStr 日期字符串
     * @return 日期对象
     */
    public static Date toDate(String dateStr, String pattern){
        return DateTime.parse(dateStr, DateTimeFormat.forPattern(pattern)).toDate();
    }

    /**
     * 生成时间
     * @param millis 毫秒
     * @return 日期
     */
    public static Date toDate(long millis) {
        return new DateTime(millis).toDate();
    }

    /**
     * 格式化日期对象
     * @param date 日期对象
     * @param format 日期格式
     * @return 当前日期字符串
     */
    public static String format(Date date, String format){
        return new DateTime(date).toString(format);
    }

    /**
     * 格式化日期对象，格式为yyyy-MM-dd HH:mm:ss
     * @param date 日期对象
     * @return 日期字符串
     */
    public static String format(Date date){
        return new DateTime(date).toString(DEFAULT_DATE_FORMAT);
    }
    /**
     * 格式化日期对象，格式为yyyyMMddHHmmss
     * @param date 日期对象
     * @return 日期字符串
     */
    public static String format2(Date date){
        return new DateTime(date).toString(DEFAULT_DATE_FORMAT2);
    }
    public static String format3(Date date){
        return new DateTime(date).toString(DEFAULT_DATE_FORMAT3);
    }

    /**
     * 格式化日期对象，格式为yyyy-MM-dd HH:mm:ss
     * @param mills 毫秒
     * @return 日期字符串
     */
    public static String format(Long mills){
        return new DateTime(mills).toString(DEFAULT_DATE_FORMAT);
    }

    /**
     * 格式化日期对象
     * @param mills 毫秒
     * @param pattern 格式
     * @return 日期字符串
     */
    public static String format(Long mills, String pattern){
        return new DateTime(mills).toString(pattern);
    }

    /**
     * 计算两个日期的时间差（单位：秒）
     *
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 时间间隔
     */
    public static long timeInterval(Date startTime, Date endTime) {
        long start = startTime.getTime();
        long end = endTime.getTime();
        return (end - start) / 1000;
    }

    /**
     * 获取指定日期当天的开始时间
     * @param date 日期
     * @return 时间
     */
    public static Date startOfDay(Date date) {
        return new DateTime(date).withTimeAtStartOfDay().toDate();
    }

    /**
     * 获取指定日期当天的结束时间
     * @param date 日期
     * @return 时间
     */
    public static Date endOfDay(Date date) {
        return new DateTime(date).millisOfDay().withMaximumValue().toDate();
    }

    /**
     * 获取本周周几的日期对象
     * @param day 1:星期一，2:星期二，...
     * @return 本周周几的日期对象
     */
    public static Date dayOfWeek(Integer day){
        return new DateTime(DateTime.now().toString("yyyy-MM-dd")).withDayOfWeek(day).toDate();
    }

    /**
     * 获取本月第几天日期对象
     * @param day 1:第一天，2:第二天，...
     * @return 本月第几天日期对象
     */
    public static Date dayOfMonth(Integer day){
        return new DateTime(DateTime.now().toString("yyyy-MM-dd")).withDayOfMonth(day).toDate();
    }

    /**
     * 获取本年第几天日期对象
     * @param day 1:第一天，2:第二天，...
     * @return 本年第几天日期对象
     */
    public static Date dayOfYear(Integer day){
        return new DateTime(DateTime.now().toString("yyyy-MM-dd")).withDayOfYear(day).toDate();
    }

    /**
     * 增加分钟
     * @param date 时间
     * @param numOfMinutes 分钟数
     * @return 时间
     */
    public static Date addMinutes(Date date, int numOfMinutes) {
        return new DateTime(date).plusMinutes(numOfMinutes).toDate();
    }

    /**
     * 增加小时
     * @param date 时间
     * @param numOfHours 小时数
     * @return 时间
     */
    public static Date addHours(Date date, int numOfHours) {
        return new DateTime(date).plusHours(numOfHours).toDate();
    }

    /**
     * 增加天数
     * @param date 时间
     * @param numdays 天数
     * @return 时间
     */
    public static Date addDays(Date date, int numdays) {
        return new DateTime(date).plusDays(numdays).toDate();
    }

    /**
     * 增加周
     * @param date 时间
     * @param numWeeks 周数
     * @return 时间
     */
    public static Date addWeeks(Date date, int numWeeks) {
        return new DateTime(date).plusWeeks(numWeeks).toDate();
    }

    /**
     * 增加月份
     * @param date 时间
     * @param numMonths 月数
     * @return 时间
     */
    public static Date addMonths(Date date, int numMonths) {
        return new DateTime(date).plusMonths(numMonths).toDate();
    }

    /**
     * 增加年
     * @param date 时间
     * @param numYears 年数
     * @return 时间
     */
    public static Date addYears(Date date, int numYears) {
        return new DateTime(date).plusYears(numYears).toDate();
    }

    /**
     * a > b ? true : false
     */
    public static Boolean isAfter(Date a, Date b){
        return new DateTime(a).isAfter(b.getTime());
    }

    /**
     * a > now() ? true : false
     */
    public static Boolean isAfterNow(Date a){
        return new DateTime(a).isAfterNow();
    }

    /**
     * a < b ? true : false
     */
    public static Boolean isBefore(Date a, Date b){
        return new DateTime(a).isBefore(b.getTime());
    }

    /**
     * a < now() ? true : false
     */
    public static Boolean isBefore(Date a){
        return new DateTime(a).isBeforeNow();
    }


    /**
     * 获得当前月的第一天
     * @param date
     * @return
     */
    public static Date startDateOfMonth(Date date) {
        DateTime dateTime = new DateTime(date);
        return dateTime.dayOfMonth().withMinimumValue().toDate();
    }

    /**
     * 获得当前月的最后一天
     * @param date
     * @return
     */
    public static Date endDateOfMonth(Date date) {
        DateTime dateTime = new DateTime(date);
        return dateTime.dayOfMonth().withMaximumValue().toDate();
    }


    /**
     * 获得当前周第一天,周一
     * @param date
     * @return
     */
    public static Date startDateOfWeek(Date date){
        DateTime dateTime = new DateTime(date);
        return dateTime.dayOfWeek().withMinimumValue().toDate();
    }

    /**
     * 获得当前周最后一天 周日
     * @param date
     * @return
     */
    public static Date endDateOfWeek(Date date){
        DateTime dateTime = new DateTime(date);
        return dateTime.dayOfWeek().withMaximumValue().toDate();
    }

    public static Integer getYear(Date date){
        return new DateTime(date).getYear();
    }

    public static Integer getMonthOfYear(Date date){
        return new DateTime(date).getMonthOfYear();
    }

    public static Integer getDayOfMonth(Date date){
        return new DateTime(date).getDayOfMonth();
    }

    /**
     * 根据开始时间和结束时间返回时间段内的时间集合
     * @param beginDate 开始日期
     * @param endDate   结束日期
     * @return          日期集合
     */
    public static Set<Date> getDatesBetweenTwoDate(Date beginDate, Date endDate) {
        Set<Date> sortSet = Sets.newTreeSet();
        if (beginDate != null && endDate != null && endDate.compareTo(beginDate) >= 0) {
            sortSet.add(startOfDay(beginDate));   // 把开始时间加入集合
            // 设置中间变量，方便计算
            Calendar tempCal = Calendar.getInstance();
            tempCal.setTime(beginDate);
            while (true) {
                // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
                tempCal.add(Calendar.DAY_OF_MONTH, 1);
                // 测试此日期是否在指定日期之后
                if (endDate.after(tempCal.getTime())) {
                    // 此处需要将日期定格在每天的开始瞬间，避免一天中多个时间算作多个element
                    sortSet.add(startOfDay(tempCal.getTime()));
                } else {
                    break;
                }
            }
            // 此处需要将日期定格在每天的开始瞬间，避免一天中多个时间算作多个element
            sortSet.add(startOfDay(endDate));   // 把结束时间加入集合
        }
        return sortSet;
    }

    /**
     * 根据开始时间和结束时间返回时间段内的时间集合
     * @param beginTime 开始时间
     * @param endTime   结束时间
     * @return          排好序的日期集合
     */
    public static Set<Date> getDatesBetweenTwoDate(Long beginTime, Long endTime) {
        if (beginTime != null && endTime != null) {
            return getDatesBetweenTwoDate(new Date(beginTime), new Date(endTime));
        }
        return Sets.newTreeSet();
    }
}

有时候还需要获取日期的年份、月份、获取月初时间，获取上个月的第一天，也可以创建一个攻工具类 

package com.test.hello.utils;

import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.time.temporal.Temporal;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.TimeZone;

public class TimeUtil {

    public static double statsDiffHour(Date endTime, Date startTime) {
        long diffTime = endTime.getTime() - startTime.getTime();
        double diff = (double) diffTime / (double) (60 * 60 * 1000);
        DecimalFormat format = new DecimalFormat("#.00");
        String str = format.format(diff);
        double dateTime = Double.parseDouble(str);
        return dateTime;
    }

    public static Date addDay(Date time, int days) {
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(time);
        // 把日期往后增加一天,整数  往后推,负数往前移动
        calendar.add(Calendar.DATE, days);
        return calendar.getTime();
    }

    public static int getMonth(Date time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);
        return calendar.get(Calendar.MONTH);
    }


    /*
     *所以这个值的初始值为0，所以我们用它来表示日历月份时需要加1
     */
    public static int getMonthAddOne(Date time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);
        return calendar.get(Calendar.MONTH)+1;
    }

    public static int getDay(Date time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);
        return calendar.get(Calendar.DATE);
    }

    /**
     * 获得日期的年份
     *
     * @param time
     * @return
     */
    public static int getYear(Date time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);
        return calendar.get(Calendar.YEAR);
    }

    public static int getYearBeforeLast(Date time) {
        //创建Calendar实例
        Calendar calendar = Calendar.getInstance();

        //设置当前时间
        calendar.setTime(time);

        //在当前时间基础上-1年
        int YearBeforeLast = calendar.get(Calendar.YEAR)-1;

        return YearBeforeLast;
    }


    /**
     * 获得月初时间
     * @param time
     * @return
     */
    public static Date getTheMonthDate(Date time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);

        Calendar newCalendar = Calendar.getInstance();
        newCalendar.clear();
        //获取年 获取月
        newCalendar.set(Calendar.YEAR, calendar.get(Calendar.YEAR));
        newCalendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH));
        //返回当前时间
        return newCalendar.getTime();
    }

    public static Date getTheDate(Date day, Date time) {
        Calendar dayCalendar = Calendar.getInstance();
        dayCalendar.setTime(day);

        Calendar timeCalendar = Calendar.getInstance();
        timeCalendar.setTime(time);

        Calendar newCalendar = Calendar.getInstance();
        newCalendar.clear();
        //获取年 获取月
        newCalendar.set(Calendar.YEAR, dayCalendar.get(Calendar.YEAR));
        newCalendar.set(Calendar.MONTH, dayCalendar.get(Calendar.MONTH));
        newCalendar.set(Calendar.DAY_OF_MONTH, dayCalendar.get(Calendar.DAY_OF_MONTH));
        newCalendar.set(Calendar.HOUR, timeCalendar.get(Calendar.HOUR));
        newCalendar.set(Calendar.MINUTE, timeCalendar.get(Calendar.MINUTE));
        newCalendar.set(Calendar.SECOND, timeCalendar.get(Calendar.SECOND));
        return newCalendar.getTime();
    }
    /**
     * 获得月初时间
     * @param year
     * @param month
     * @return
     */
    public static Date getTheMonthDate(int year, int month) {
        Calendar newCalendar = Calendar.getInstance();
        newCalendar.clear();
        newCalendar.set(Calendar.YEAR, year);
        newCalendar.set(Calendar.MONTH, month);
        return newCalendar.getTime();
    }


    /**
     * 获取当年年初
     * @param time
     * @return
     */
    public static Date getTheYearDate(Date time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);

        Calendar newCalendar = Calendar.getInstance();
        newCalendar.clear();
        newCalendar.set(Calendar.YEAR, calendar.get(Calendar.YEAR));
        return newCalendar.getTime();
    }


    /**
     * 获取下一年年初
     * @param time
     * @return
     */
    public static Date getLaterYearDate(Date time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);

        Calendar newCalendar = Calendar.getInstance();
        newCalendar.clear();
        newCalendar.set(Calendar.YEAR, calendar.get(Calendar.YEAR) + 1);
        return newCalendar.getTime();
    }


    /**
     * 获取当年上一个月
     * @param time
     * @return
     */
    public static Date getTheYearLastMonthDate(Date time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);

        Calendar newCalendar = Calendar.getInstance();
        newCalendar.clear();
        //获取年 获取上一个月
        newCalendar.set(Calendar.YEAR, calendar.get(Calendar.YEAR));
        newCalendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) - 1);
        //返回当前时间
        return newCalendar.getTime();
    }

    /**
     * 获取当年下一个月
     * @param time
     * @return
     */
    public static Date getTheYearLaterMonthDate(Date time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);

        Calendar newCalendar = Calendar.getInstance();
        newCalendar.clear();
        //获取年 获取上一个月
        newCalendar.set(Calendar.YEAR, calendar.get(Calendar.YEAR));
        newCalendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) + 1);
        //返回当前时间
        return newCalendar.getTime();
    }

    /**
     * 获取上一年同期
     * @param time
     * @return
     */
    public static Date getLastYearTheMonthDate(Date time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);

        Calendar newCalendar = Calendar.getInstance();
        newCalendar.clear();
        newCalendar.set(Calendar.YEAR, calendar.get(Calendar.YEAR) - 1);
        newCalendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH));
        return newCalendar.getTime();
    }

    /**
     * 获取上一年年初
     * @param time
     * @return
     */
    public static Date getLastYearDate(Date time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);

        Calendar newCalendar = Calendar.getInstance();
        newCalendar.clear();
        newCalendar.set(Calendar.YEAR, calendar.get(Calendar.YEAR) - 1);
        return newCalendar.getTime();
    }

    public static int getTheDaysBetweenNow(Date time) {
        if (time == null) {
            return 0;
        }
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Temporal nowTempral = LocalDate.parse(dateFormat.format(new Date()));
        Temporal tempral = LocalDate.parse(dateFormat.format(time));
        //当前时间大于time为正，当前时间小于time为负
        long days = ChronoUnit.DAYS.between(tempral, nowTempral);
        return (int) days;
    }

    public static int getTheYearsBetweenNow(Date time) {
        if (time == null) {
            return 0;
        }
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Temporal nowTempral = LocalDate.parse(dateFormat.format(new Date()));
        Temporal tempral = LocalDate.parse(dateFormat.format(time));
        //当前时间大于time为正，当前时间小于time为负
        long years = ChronoUnit.YEARS.between(tempral, nowTempral);
        return (int) years;
    }

    public static int getTheDaysBetween(Date startTime, Date endTime) {
        if (startTime == null || endTime == null) {
            return 0;
        }
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Temporal startTempral = LocalDate.parse(dateFormat.format(startTime));
        Temporal endTempral = LocalDate.parse(dateFormat.format(endTime));
        long days = ChronoUnit.DAYS.between(startTempral, endTempral);
        return (int) days;
    }

    public static boolean checkIfSameYear(Date time1, Date time2) {
        if (time1 == null || time2 == null) {
            return false;
        }
        int year1 = getYear(time1);
        int year2 = getYear(time2);
        return year1 == year2;
    }

    /**
     * 获取指定日期格式的字符串
     *
     * @param date
     * @param format
     * @return
     */
    public static String getTimeStr(Date date, String format) {
        return new SimpleDateFormat(format).format(date);
    }

    /**
     * 获取一周后的日期
     *
     * @param currentDate
     * @return
     */
    public static Date getNextWeekDate(Date currentDate) {
        TimeZone.setDefault(TimeZone.getTimeZone("GMT+8"));
        // 创建一个Calendar对象
        Calendar calendar = Calendar.getInstance();
        // 将Calendar对象设置为当前日期
        calendar.setTime(currentDate);
        // 将日期增加一周
        calendar.add(Calendar.WEEK_OF_YEAR, 1);
        // 获取增加一周后的日期
        Date oneWeekLater = calendar.getTime();
        // 输出增加一周后的日期
        // String format = new SimpleDateFormat("yyyy-MM-dd").format(oneWeekLater);
        // System.out.println("一周后的日期：" + format);
        return oneWeekLater;
    }
}