DateUtils 工具类（封装一些关于时间的操作）

package com.test.common.util;

import java.sql.Timestamp;
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.ZoneId;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.Locale;
import java.util.TimeZone;
import java.util.regex.Pattern;

import cn.hutool.log.Log;
import cn.hutool.log.LogFactory;
import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;

import com.isearch.common.ResultStatus;

/**
 * 封装一些关于时间的操作
 *
 */
public class DateUtils{
    static Log log = LogFactory.get(DateUtils.class);
    
    /**
     * 时间格式
     */
    public static final String FORMART_yyyyMMdd = "yyyyMMdd";
    
    public static final String FORMART_yyyyMMddHHmmss = "yyyyMMddHHmmss";
    
    public static final String FORMART_yyyyMMddHHmmssSSS = "yyyyMMddHHmmssSSS";
    
    public static final String FORMART_FULL = "yyyy-MM-dd HH:mm:ss";
    
    public static final String FORMART_DATE = "yyyy-MM-dd";
    
    public static final String FORMART_HH = "HH";
    
    public static final String FORMART_TIME = "HH:mm:ss";
    
    /**
     * 默认UTC格式
     */
    public static final String FORMART_UTC = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'";
    
    /**
     * 带时区信息的UTC格式
     */
    public static final String UTC_ZONE_FORMATER = "yyyy-MM-dd'T'HH:mm:ss.SSSZ";
    
    /**
     * logTime 时间格式
     */
    public static final String LOGTIME_FORMATTER = "yyyy-MM-dd HH:mm:ss,SSS";
    
    /**
     * 默认地区信息 en_US
     */
    public static final String DEFAULT_LOCAL = "en_US";
    
    /**
     * 秒，分，时，天包含的毫秒
     */
    public static final long SECOND_MIS = 1000;
    
    public static final long MINUTE_MIS = SECOND_MIS * 60;
    
    public static final long HOUR_MIS = MINUTE_MIS * 60;
    
    public static final long DAY_MIS = HOUR_MIS * 24;
    
    public static final String TIME_TYPE_TODAY = "toDay";
    
    public static final String TIME_TYPE_YESTERDAY = "yesterDay";
    
    public static final String TIME_TYPE_LAST_SEVEN_DAYS = "sevenDays";
    
    public static final String TIME_TYPE_LAST_THIRTY_DAYS = "thirtyDays";
    
    private DateUtils(){
    }
    
    /**
     * 获取当前时间
     *
     * @return
     */
    public static Date getNow(){
        return new Date();
    }
    
    /**
     * 获取当前字符串 yyyy-MM-dd HH:mm:ss
     *
     * @return
     */
    public static String full(){
        return formatDate(getNow(), FORMART_FULL);
    }
    
    /**
     * 获取当前字符串 yyyy-MM-dd HH:mm:ss
     *
     * @return
     */
    public static String getCurrentDate(){
        return formatDate(getNow(), FORMART_FULL);
    }
    
    /**
     * 获取当前日期字符串 yyyy-MM-dd
     *
     * @return
     */
    public static String date(){
        return formatDate(getNow(), FORMART_DATE);
    }
    
    /**
     * 获取当前时间字符串 HH:mm:ss
     *
     * @return
     */
    public static String time(){
        return formatDate(getNow(), FORMART_TIME);
    }
    
    /**
     * 格式化日期 yyyy-MM-dd HH:mm:ss
     *
     * @param  date
     * @return
     */
    public static String formatDate(Date date){
        return formatDate(date, FORMART_FULL);
    }
    
    /**
     * 格式化日期 yyyyMMddHHmmss
     *
     * @param  date
     * @return
     */
    public static String formatDateWX(Date date){
        return formatDate(date, FORMART_yyyyMMddHHmmss);
    }
    
    /**
     * 格式化日期,指定格式
     *
     * @param  date
     * @param  type
     * @return
     */
    public static String formatDate(Date date, String type){
        
        if (date == null) {
            return null;
        }
        
        if (StringUtils.isBlank(type)) {
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(type);
        return sdf.format(date);
    }
    
    /**
     * 格式化日期,指定格式
     *
     * @param  date
     * @param  type
     * @return
     */
    public static String formatDateString(String date, String type){
        
        if (date == null) {
            return null;
        }
        
        if (StringUtils.isBlank(type)) {
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(type);
        return sdf.format(parseDate(date));
    }
    
    /**
     * 格式化日期,指定格式和本地语言
     *
     * @param  date
     * @param  type
     * @param  local
     * @return
     */
    public static String formatDate(Date date, String type, String local){
        
        if (date == null) {
            return null;
        }
        
        if (StringUtils.isBlank(type)) {
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(type, new Locale(local));
        String result = null;
        
        try {
            result = sdf.format(date);
        } catch (Exception e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return result;
    }
    
    /**
     * Date转换成字符串
     *
     * @param  date
     * @return      yyyy-MM-dd
     */
    public static String dateToStr(Date date){
        SimpleDateFormat formatter = new SimpleDateFormat(FORMART_DATE);
        String format = "";
        
        try {
            format = formatter.format(date);
        } catch (Exception e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return format;
    }
    
    /**
     * Date转换成字符串
     *
     * @param  date
     * @return      yyyy-MM-dd
     */
    public static String dateString(Date date){
        SimpleDateFormat formatter = new SimpleDateFormat(FORMART_FULL);
        String format = "";
        
        try {
            format = formatter.format(date);
        } catch (Exception e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return format;
    }
    
    /**
     * 字符串转换成Date
     *
     * @param  date
     * @return      yyyy-MM-dd
     */
    public static Date strToDate(String date){
        Date Result = null;
        SimpleDateFormat formatter = new SimpleDateFormat(getDatetimeFormat(date));
        
        try {
            Result = formatter.parse(date);
        } catch (Exception e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return Result;
    }
    
    /**
     * 取得系统当前时间前n天
     *
     * @param  n int
     * @return   String yyyymmdd
     */
    public static String getNDayBeforeCurrentDate(int n){
        Calendar c = Calendar.getInstance();
        c.add(Calendar.DAY_OF_MONTH, -n);
        String math = null;
        String date = null;
        
        if (c.get(Calendar.MONTH) + 1 < 10) {
            math = "0" + (c.get(Calendar.MONTH) + 1);
        } else {
            math = String.valueOf(c.get(Calendar.MONTH) + 1);
        }
        
        if (c.get(Calendar.DATE) < 10) {
            date = "0" + c.get(Calendar.DATE);
        } else {
            date = String.valueOf(c.get(Calendar.DATE));
        }
        return "" + c.get(Calendar.YEAR) + math + date;
    }
    
    public static String getTimeDays(int past){
        return getPastDate(past, FORMART_FULL);
    }
    
    public static String getTimeDay(int past){
        return getPastDate(past, FORMART_DATE);
    }
    
    /**
     * 取得系统当前时间后n天
     *
     * @param  n int
     * @return   String yyyymmdd
     */
    public static String getDayBeforeCurrentDate(int n){
        Calendar c = Calendar.getInstance();
        c.add(Calendar.DAY_OF_MONTH, n);
        String math = null;
        String date = null;
        
        if (c.get(Calendar.MONTH) + 1 < 10) {
            math = "0" + (c.get(Calendar.MONTH) + 1);
        } else {
            math = String.valueOf(c.get(Calendar.MONTH) + 1);
        }
        
        if (c.get(Calendar.DATE) < 10) {
            date = "0" + c.get(Calendar.DATE);
        } else {
            date = String.valueOf(c.get(Calendar.DATE));
        }
        return "" + c.get(Calendar.YEAR) + math + date;
    }
    
    /**
     * 获取今天、昨天、最近7天、最近30天
     * @param  timeType
     * @return
     */
    public static String[] timeFrame(String timeType){
        String timeStart = null;
        String timeEnd = null;
        
        if (StringUtils.isNotBlank(timeType)) {
            
            if (TIME_TYPE_TODAY.equals(timeType)) {
                timeStart = DateUtils.date() + " 00:00:00";
                timeEnd = DateUtils.full();
            }
            
            if (TIME_TYPE_YESTERDAY.equals(timeType)) {
                timeStart = DateUtils.getTimeDay(1) + " 00:00:00";
                timeEnd = DateUtils.getTimeDay(1) + " 23:59:59";
            }
            
            if (TIME_TYPE_LAST_SEVEN_DAYS.equals(timeType)) {
                timeStart = DateUtils.getTimeDays(7);
                timeEnd = DateUtils.full();
            }
            
            if (TIME_TYPE_LAST_THIRTY_DAYS.equals(timeType)) {
                timeStart = DateUtils.getTimeDays(30);
                timeEnd = DateUtils.full();
            }
            String[] array = new String[2];
            array[0] = timeStart;
            array[1] = timeEnd;
            return array;
        } else {
            return null;
        }
    }
    
    /**
     * 对当前日期，进行加减天数，得到时间戳值
     * 
     * @param  days 要加减的天数
     * @return
     */
    public static long addDays(int days){
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        
        cal.set(Calendar.DAY_OF_MONTH, cal.get(Calendar.DAY_OF_MONTH) + days);
        
        return cal.getTimeInMillis();
    }
    
    /**
     * 解析时间字符串,指定格式
     *
     * @param  value
     * @param  type
     * @return
     */
    public static Date parseDate(String value, String type){
        
        try {
            
            if (StringUtils.isBlank(value)) {
                return null;
            }
            
            SimpleDateFormat sdf = new SimpleDateFormat(type);
            return sdf.parse(value);
        } catch (ParseException e) {
            log.info("异常：{}", e.getMessage());
        }
        
        return null;
    }
    
    /**
     * 解析时间字符串,指定格式和本地语言
     *
     * @param  value
     * @param  type
     * @return
     */
    public static Date parseDate(String value, String type, String local){
        
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(type, new Locale(local));
            return sdf.parse(value);
        } catch (ParseException e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return null;
    }
    
    /**
     * 解析时间字符串
     *
     * @param  value
     * @return
     */
    public static Date parseDate(String value){
        return parseDate(value, FORMART_FULL);
    }
    
    /**
     * 解析时间字符串
     *
     * @param  value
     * @return
     */
    public static Date parseDateA(String value){
        return parseDate(value, FORMART_DATE);
    }
    
    /**
     * 把UTC时间转成本地时间,指定UTC格式
     *
     * @param  utcDate
     * @param  utcTimePatten
     * @return
     */
    public static String utc2Local(String utcDate, String utcTimePatten){
        return utc2Local(utcDate, utcTimePatten, FORMART_FULL);
    }
    
    /**
     * 把UTC时间转成本地时间,指定UTC格式和本地语言
     *
     * @param  utcDate
     * @param  utcTimePatten
     * @param  localTimePatten
     * @return
     */
    public static String utc2Local(String utcDate, String utcTimePatten, String localTimePatten){
        
        try {
            SimpleDateFormat utcFormater = new SimpleDateFormat(utcTimePatten);
            utcFormater.setTimeZone(TimeZone.getTimeZone("UTC"));
            Date gpsUTCDate = utcFormater.parse(utcDate);
            SimpleDateFormat localFormater = new SimpleDateFormat(localTimePatten);
            localFormater.setTimeZone(TimeZone.getDefault());
            return localFormater.format(gpsUTCDate.getTime());
        } catch (ParseException e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return null;
    }
    
    /**
     * Date转成字符串
     *
     * @param date
     */
    public static String dateToString(Date date){
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return format.format(date);
    }
    
    /**
     * 把UTC时间转成本地时间
     *
     * @param  utcStamp
     * @return
     */
    public static String utc2Local(long utcStamp){
        return utc2Local(formatDate(new Date(utcStamp)), FORMART_FULL);
    }
    
    /**
     * 把UTC时间转成本地时间,指定本地时间格式
     *
     * @param  utcStamp
     * @param  localTimePatten
     * @return
     */
    public static String utc2Local(long utcStamp, String localTimePatten){
        return utc2Local(formatDate(new Date(utcStamp)), FORMART_FULL, localTimePatten);
    }
    
    /**
     * 本地时间转成UTC时间
     *
     * @param  localDate
     * @return
     */
    public static String local2Utc(String localDate){
        return local2Utc(localDate, FORMART_UTC, FORMART_FULL);
    }
    
    /**
     * 本地时间转成UTC时间,指定本地时间格式
     *
     * @param  localDate
     * @param  localTimePatten
     * @return
     */
    public static String local2Utc(String localDate, String localTimePatten){
        return local2Utc(localDate, FORMART_UTC, localTimePatten);
    }
    
    /**
     * 本地时间转成UTC时间,指定UTC时间格式和本地时间格式
     *
     * @param  localDate
     * @param  utcTimePatten
     * @param  localTimePatten
     * @return
     */
    public static String local2Utc(String localDate, String utcTimePatten, String localTimePatten){
        
        try {
            SimpleDateFormat localFormater = new SimpleDateFormat(localTimePatten);
            localFormater.setTimeZone(TimeZone.getDefault());
            Date gpsLocalDate = localFormater.parse(localDate);
            SimpleDateFormat utcFormater = new SimpleDateFormat(utcTimePatten);
            utcFormater.setTimeZone(TimeZone.getTimeZone("UTC"));
            return utcFormater.format(gpsLocalDate.getTime());
        } catch (ParseException e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return null;
    }
    
    /**
     * 本地时间转成UT毫秒时间
     *
     * @param  localDate
     * @return
     */
    public static long local2Utcstamp(String localDate){
        return local2Utcstamp(localDate, FORMART_FULL);
    }
    
    /**
     * 本地时间转成UT毫秒时间,指定本地时间格式
     *
     * @param  localDate
     * @param  localTimePatten
     * @return
     */
    public static long local2Utcstamp(String localDate, String localTimePatten){
        
        try {
            SimpleDateFormat localFormater = new SimpleDateFormat(localTimePatten);
            localFormater.setTimeZone(TimeZone.getDefault());
            Date gpsLocalDate = localFormater.parse(localDate);
            
            Calendar c = Calendar.getInstance();
            c.setTime(gpsLocalDate);
            // 取得时间偏移量
            int zoneOffset = c.get(Calendar.ZONE_OFFSET);
            // 取得夏令时差
            int dstOffset = c.get(Calendar.DST_OFFSET);
            // 从本地时间里扣除这些差量，即可以取得UTC时间
            c.add(Calendar.MILLISECOND, -(zoneOffset + dstOffset));
            
            return c.getTimeInMillis();
        } catch (ParseException e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return 0;
    }
    
    /**
     * 毫秒时间转成字符串时间
     *
     * @param  timeStamp
     * @return
     */
    public static String timeStampToDate(long timeStamp){
        return timeStampToDate(timeStamp, FORMART_FULL);
    }
    
    public static String timeStampToDate(long timeStamp, String format){
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String sd = sdf.format(new Date(Long.parseLong(String.valueOf(timeStamp))));
        return sd;
    }
    
    /**
     * 字符串时间转成毫秒时间
     *
     * @param  date
     * @return
     */
    public static long dateToTimeStamp(String date){
        SimpleDateFormat sdf = new SimpleDateFormat(FORMART_FULL);
        Date dateToTimeStamp;
        
        try {
            dateToTimeStamp = sdf.parse(date);
            return dateToTimeStamp.getTime();
        } catch (ParseException e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return 0;
    }

    /**
     * 字符串时间转成毫秒时间
     *
     * @param  date
     * @return
     */
    public static long dateToTimeStamp(String date, String format){
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date dateToTimeStamp;

        try {
            dateToTimeStamp = sdf.parse(date);
            return dateToTimeStamp.getTime();
        } catch (ParseException e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return 0;
    }

    /**
     * 查看时间是否在给定时间之内
     *
     * @param  sourceDate
     * @param  destBeginDate
     * @param  destEndDate
     * @return
     */
    public static boolean dateIn(String sourceDate, String destBeginDate, String destEndDate){
        return dateIn(sourceDate, destBeginDate, destEndDate, FORMART_FULL);
    }
    
    /**
     * 查看时间是否在给定时间之内
     *
     * @param  sourceDate
     * @param  destBeginDate
     * @param  destEndDate
     * @param  format
     * @return
     */
    public static boolean dateIn(String sourceDate, String destBeginDate, String destEndDate, String format){
        
        try {
            SimpleDateFormat formater = new SimpleDateFormat(format);
            return dateIn(formater.parse(sourceDate).getTime(), formater.parse(destBeginDate).getTime(),
                formater.parse(destEndDate).getTime());
        } catch (ParseException e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return false;
    }
    
    /**
     * 查看时间是否在给定时间之内
     *
     * @param  sourceDate
     * @param  destBeginDate
     * @param  destEndDate
     * @return
     */
    public static boolean dateIn(long sourceDate, long destBeginDate, long destEndDate){
        return (sourceDate >= destBeginDate) && (sourceDate <= destEndDate);
    }
    
    /**
     * 查看时间是否大于目标时间
     *
     * @param  sourceDate
     * @param  destDate
     * @return
     */
    public static boolean dateAfter(String sourceDate, String destDate){
        return dateAfter(sourceDate, destDate, FORMART_FULL);
    }
    
    /**
     * 查看时间是否大于目标时间
     *
     * @param  sourceDate
     * @param  destDate
     * @param  format
     * @return
     */
    public static boolean dateAfter(String sourceDate, String destDate, String format){
        
        try {
            SimpleDateFormat formater = new SimpleDateFormat(format);
            Date source = formater.parse(sourceDate);
            Date dest = formater.parse(destDate);
            return dateAfter(source, dest);
        } catch (ParseException e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return false;
    }
    
    /**
     * 查看时间是否大于目标时间
     *
     * @param  sourceDate
     * @param  destDate
     * @return
     */
    public static boolean dateAfter(Date sourceDate, Date destDate){
        return sourceDate.after(destDate);
    }
    
    /**
     * 查看时间是否大于或等于目标时间
     *
     * @param  sourceDate
     * @param  destDate
     * @return
     */
    public static boolean dateAfterEqual(String sourceDate, String destDate){
        return dateAfterEqual(sourceDate, destDate, FORMART_FULL);
    }
    
    /**
     * 查看时间是否大于或等于目标时间
     *
     * @param  sourceDate
     * @param  destDate
     * @param  format
     * @return
     */
    public static boolean dateAfterEqual(String sourceDate, String destDate, String format){
        
        try {
            SimpleDateFormat formater = new SimpleDateFormat(format);
            Date source = formater.parse(sourceDate);
            Date dest = formater.parse(destDate);
            return source.after(dest) || source.getTime() == dest.getTime();
        } catch (ParseException e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return false;
    }
    
    /**
     * 查看时间是否小于目标时间
     *
     * @param  sourceDate
     * @param  destDate
     * @return
     */
    public static boolean dateBefore(String sourceDate, String destDate){
        return dateBefore(sourceDate, destDate, FORMART_FULL);
    }
    
    /**
     * 查看时间是否小于目标时间
     *
     * @param  sourceDate
     * @param  destDate
     * @param  format
     * @return
     */
    public static boolean dateBefore(String sourceDate, String destDate, String format){
        
        try {
            SimpleDateFormat formater = new SimpleDateFormat(format);
            Date source = formater.parse(sourceDate);
            Date dest = formater.parse(destDate);
            return source.before(dest);
        } catch (ParseException e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return false;
    }
    
    /**
     * 查看时间是否小于或等于目标时间
     *
     * @param  sourceDate
     * @param  destDate
     * @return
     */
    public static boolean dateBeforeEqual(String sourceDate, String destDate){
        return dateBeforeEqual(sourceDate, destDate, FORMART_FULL);
    }
    
    /**
     * 查看时间是否小于或等于目标时间
     *
     * @param  sourceDate
     * @param  destDate
     * @param  format
     * @return
     */
    public static boolean dateBeforeEqual(String sourceDate, String destDate, String format){
        
        try {
            SimpleDateFormat formater = new SimpleDateFormat(format);
            Date source = formater.parse(sourceDate);
            Date dest = formater.parse(destDate);
            return source.before(dest) || source.getTime() == dest.getTime();
        } catch (ParseException e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return false;
    }
    
    /**
     * 获得给定的2个时间间隔[秒]
     *
     * @param  src
     * @param  dest
     * @return
     */
    public static long getIntervals(Date src, Date dest){
        
        if (src == null || dest == null) {
            return 0l;
        }
        
        Calendar nc = Calendar.getInstance();
        nc.setTime(src);
        Calendar oc = Calendar.getInstance();
        oc.setTime(dest);
        return (nc.getTimeInMillis() - oc.getTimeInMillis()) / 1000;
    }
    
    /**
     * 获得给定的2个时间间隔[毫秒]
     *
     * @param  src
     * @param  dest
     * @return
     */
    public static long getInterval(String src, String dest){
        
        if (src == null || dest == null) {
            return 0;
        }
        
        Date start = parseDate(src, FORMART_FULL);
        Date end = parseDate(dest, FORMART_FULL);
        
        if (start == null || end == null) {
            return 0;
        }
        
        long time = end.getTime() - start.getTime();
        return time <= 0 ? 0 : time;
    }
    
    /**
     * 指定日期加上减去x年
     *
     * @param  date
     * @param  amount
     * @return
     */
    public static Date addYears(Date date, int amount){
        return add(date, Calendar.YEAR, amount);
    }
    
    /**
     * 指定日期加上减去x月
     *
     * @param  date
     * @param  amount
     * @return
     */
    public static Date addMonths(Date date, int amount){
        return add(date, Calendar.MONTH, amount);
    }
    
    /**
     * 指定日期加上减去x周
     *
     * @param  date
     * @param  amount
     * @return
     */
    public static Date addWeeks(Date date, int amount){
        return add(date, Calendar.WEEK_OF_YEAR, amount);
    }
    
    /**
     * 指定日期加上减去x天
     *
     * @param  date
     * @param  amount
     * @return
     */
    public static Date addDays(Date date, int amount){
        return add(date, Calendar.DAY_OF_MONTH, amount);
    }
    
    /**
     * 指定日期加上减去x小时
     *
     * @param  date
     * @param  amount
     * @return
     */
    public static Date addHours(Date date, int amount){
        return add(date, Calendar.HOUR_OF_DAY, amount);
    }
    
    /**
     * 指定日期加上减去x分钟
     *
     * @param  date
     * @param  amount
     * @return
     */
    public static Date addMinutes(Date date, int amount){
        return add(date, Calendar.MINUTE, amount);
    }
    
    /**
     * 指定日期加上减去x秒
     *
     * @param  date
     * @param  amount
     * @return
     */
    public static Date addSeconds(Date date, int amount){
        return add(date, Calendar.SECOND, amount);
    }
    
    /**
     * 指定日期加上减去x毫秒
     *
     * @param  date
     * @param  amount
     * @return
     */
    public static Date addMilliseconds(Date date, int amount){
        return add(date, Calendar.MILLISECOND, amount);
    }
    
    /**
     * 日期指定操作
     *
     * @param  date
     * @param  calendarField
     * @param  amount
     * @return
     */
    private static Date add(Date date, int calendarField, int amount){
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.add(calendarField, amount);
        return c.getTime();
    }
    
    /**
     * 设置指定日期的年
     *
     * @param  date
     * @param  amount
     * @return
     */
    public static Date setYears(Date date, int amount){
        return set(date, Calendar.YEAR, amount);
    }
    
    /**
     * 设置指定日期的月
     *
     * @param  date
     * @param  amount
     * @return
     */
    public static Date setMonths(Date date, int amount){
        return set(date, Calendar.MONTH, amount);
    }
    
    /**
     * 设置指定日期的天
     *
     * @param  date
     * @param  amount
     * @return
     */
    public static Date setDays(Date date, int amount){
        return set(date, Calendar.DAY_OF_MONTH, amount);
    }
    
    /**
     * 设置指定日期的小时
     *
     * @param  date
     * @param  amount
     * @return
     */
    public static Date setHours(Date date, int amount){
        return set(date, Calendar.HOUR_OF_DAY, amount);
    }
    
    /**
     * 设置指定日期的分钟
     *
     * @param  date
     * @param  amount
     * @return
     */
    public static Date setMinutes(Date date, int amount){
        return set(date, Calendar.MINUTE, amount);
    }
    
    /**
     * 设置指定日期的秒
     *
     * @param  date
     * @param  amount
     * @return
     */
    public static Date setSeconds(Date date, int amount){
        return set(date, Calendar.SECOND, amount);
    }
    
    /**
     * 设置指定日期的毫秒
     *
     * @param  date
     * @param  amount
     * @return
     */
    public static Date setMilliseconds(Date date, int amount){
        return set(date, Calendar.MILLISECOND, amount);
    }
    
    /**
     * 设置指定日期
     *
     * @param  date
     * @param  calendarField
     * @param  amount
     * @return
     */
    private static Date set(Date date, int calendarField, int amount){
        Calendar c = Calendar.getInstance();
        c.setLenient(false);
        c.setTime(date);
        c.set(calendarField, amount);
        return c.getTime();
    }
    
    /**
     * 获取某一天的日期，明天为1，昨天为-1
     *
     * @param  i
     * @return
     */
    public static String getDayDate(int i){
        Date date = new Date();// 取时间
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        calendar.add(Calendar.DATE, i);// 把日期往后增加一天.整数往后推,负数往前移动
        date = calendar.getTime(); // 这个时间就是日期往后推一天的结果
        SimpleDateFormat formatter = new SimpleDateFormat(FORMART_DATE);
        String dateString = formatter.format(date);
        return dateString;
    }
    
    public static Boolean compareDate(Date date1, Date date2){
        
        if (date1.before(date2)) {
            return false;
        } else if (date1.after(date2)) {
            return true;
        } else {
            return true;
        }
    }
    
    /**
     * 返回时分秒
     *
     * @param  seconds 秒
     * @return
     */
    public static String countTimeDiff(Timestamp start, Timestamp end){
        
        try {
            
            if (null == start || null == end) {
                return null;
            }
            long seconds = end.getTime() - start.getTime();
            
            if (seconds < 0) {
                return null;
            }
            return secondFormateTime(seconds / 1000);
        } catch (Exception e) {
            log.debug(e);
            return null;
        }
    }
    
    /**
     * 返回时分秒，
     *
     * @param  seconds 秒
     * @return
     */
    public static String secondFormateTime(long seconds){
        long hours = seconds / 3600;// 转换小时数
        seconds = seconds % 3600;// 剩余秒数
        long minutes = seconds / 60;// 转换分钟
        seconds = seconds % 60;// 剩余秒数
        String hour = hours == 0 ? ""
            : ((hours + "").toString().length() < 2 ? "0" + (hours + "") : (hours + "")) + ResultStatus.HOUR.getMsg();
        String minute = minutes == 0 ? ""
            : ((minutes + "").toString().length() < 2 ? "0" + (minutes + "") : (minutes + "")) + ResultStatus.MINUTE.getMsg();
        String second = seconds == 0 ? ""
            : ((seconds + "").toString().length() < 2 ? "0" + (seconds + "") : (seconds + "")) + ResultStatus.SECOND.getMsg();
        
        if (0 == hours && 0 == minutes && 0 == seconds) {
            second = "0" + ResultStatus.SECOND.getMsg();
        }
        
        return hour + minute + second;
    }
    
    /**
     * 返回小时数（四舍五入）
     *
     * @param  seconds 秒
     * @return
     */
    public static long secondToHours(long seconds){
        long hours = seconds / 3600;// 转换小时数
        seconds = seconds % 3600;// 剩余秒数
        long minutes = seconds / 60;// 转换分钟
        
        if (minutes >= 30) {
            hours++;
        }
        return hours;
    }
    
    /**
     * 返回分钟数（四舍五入）
     *
     * @param  seconds 秒
     * @return
     */
    public static long secondMinutes(long seconds){
        long minutes = seconds / 60;// 转换成
        seconds = seconds % 60;// 剩余秒数
        
        if (seconds >= 30) {
            minutes++;
        }
        return minutes;
    }
    
    /**
     * 通过时间秒毫秒数判断两个时间的间隔
     *
     * @param  date1
     * @param  date2
     * @return
     */
    public static int dateDays(String date1, String date2){
        Date d1 = parseDate(date1);
        Date d2 = parseDate(date2);
        
        if (d1 == null || d2 == null) {
            return 0;
        }
        
        int days = (int) ((d2.getTime() - d1.getTime()) / (1000 * 3600 * 24));
        int i = (int) (d2.getTime() - d1.getTime());
        
        return (i > 0 && i <= 86400000) ? 0 : days;
    }
    
    /**
     * 获取当月的每一天日期
     *
     * @return
     */
    public static List<String> getDayListOfMonth(Date date){
        List<String> list = new ArrayList<String>();
        Calendar aCalendar = Calendar.getInstance(Locale.CHINA);
        aCalendar.setTime(date);
        int year = aCalendar.get(Calendar.YEAR);// 年份
        int month = aCalendar.get(Calendar.MONTH) + 1;// 月份
        String monthCon = month > 9 ? "" + month : "0" + month;
        int day = aCalendar.getActualMaximum(Calendar.DATE);
        
        for (int i = 1; i <= day; i++) {
            String dayCon = i > 9 ? "" + i : "0" + i;
            String aDate = String.valueOf(year) + "-" + monthCon + "-" + dayCon;
            list.add(aDate);
        }
        return list;
    }
    
    /**
     * 获取指定年份和月份的最后一天
     *
     * @param  year
     * @param  month
     * @return
     */
    public static String getDateLastDay(int year, int month){
        // year="2018" month="2"
        Calendar calendar = Calendar.getInstance();
        // 设置时间,当前时间不用设置
        calendar.set(Calendar.YEAR, year);
        calendar.set(Calendar.MONTH, month - 1);
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.DATE, calendar.getActualMaximum(Calendar.DATE));
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd ");
        return format.format(calendar.getTime());
    }
    
    /**
     * 得到某个月份的第一天的日期
     *
     * @param  year
     * @param  month
     * @return
     */
    public static String getFirstDayOfMonth(int year, int month){
        Calendar cal = Calendar.getInstance();
        // 设置月份
        cal.set(Calendar.YEAR, year);
        cal.set(Calendar.MONTH, month - 1);
        // 获取某月最小天数
        int firstDay = cal.getActualMinimum(Calendar.DAY_OF_MONTH);
        // 设置日历中月份的最小天数
        cal.set(Calendar.DAY_OF_MONTH, firstDay);
        // 格式化日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String firstDayOfMonth = sdf.format(cal.getTime());
        return firstDayOfMonth;
    }
    
    /**
     * 2个时间相减，得到天数
     *
     * @param  startDate
     * @param  endDate
     * @return
     */
    public static long until(String startDate, String endDate){
        Date start = parseDate(startDate, "yyyy-MM-dd");
        Date end = parseDate(endDate, "yyyy-MM-dd");
        
        if (start == null || end == null) {
            return 0;
        }
        
        Instant instant1 = start.toInstant();
        Instant instant2 = end.toInstant();
        ZoneId zone = ZoneId.systemDefault();
        LocalDate localStart = LocalDateTime.ofInstant(instant1, zone).toLocalDate();
        LocalDate localEnd = LocalDateTime.ofInstant(instant2, zone).toLocalDate();
        return localStart.until(localEnd, ChronoUnit.DAYS);
    }
    
    /**
     * 获取一周每天的日期
     *
     * @param  date
     * @return
     */
    public static List<String> getTimeInterval(Date date){
        List<String> list = new ArrayList<String>();
        SimpleDateFormat sdf = new SimpleDateFormat(DateUtils.FORMART_DATE);
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        // 判断要计算的日期是否是周日，如果是则减一天计算周六的，否则会出问题，计算到下一周去了
        int dayWeek = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天
        
        if (1 == dayWeek) {
            cal.add(Calendar.DAY_OF_MONTH, -1);
        }
        // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        // 获得当前日期是一个星期的第几天
        int day = cal.get(Calendar.DAY_OF_WEEK);
        // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
        cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
        String imptimeBegin = sdf.format(cal.getTime());
        list.add(imptimeBegin);
        
        for (int i = 1; i <= 6; i++) {
            cal.add(Calendar.DATE, 1);
            list.add(sdf.format(cal.getTime()));
        }
        return list;
    }
    
    /**
     * 指定时间添加自定义的天数
     *
     * @param  date
     * @param  count
     * @return
     */
    public static List<String> addDaysCount(Date date, int count){
        List<String> list = new ArrayList<String>();
        list.add(formatDate(date, FORMART_DATE));
        
        for (int i = 1; i <= count; i++) {
            list.add(formatDate(addDays(date, i), FORMART_DATE));
        }
        return list;
    }
    
    public static List<String> getSevenDays(int intervals){
        List<String> pastDaysList = new ArrayList<>();
        
        for (int i = intervals - 1; i >= 0; i--) {
            pastDaysList.add(getPastDate(i));
        }
        return pastDaysList;
    }
    
    /**
     * 获取当前时间并且格式化精确到毫秒
     *
     * @return
     */
    public static String getLocalDate(){
        DateTime dateTime = new DateTime();
        String str = dateTime.toString(FORMART_yyyyMMddHHmmssSSS);
        return str;
    }
    
    /**
     * 获取指定月份的天数
     *
     * @param  date
     * @return
     */
    public static int getDaysOfMonth(String date){
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(parseDate(date));
        return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
    }
    
    /**
     * 修改时间最后为 23:59:59
     *
     * @param  date
     * @return
     */
    public static Date changeTime(Date date){
        String dataStr = DateUtils.formatDate(date, "yyyy-MM-dd HH:mm:ss");
        
        if (dataStr != null) {
            String dateStrEnd = dataStr.substring(0, 10) + " 23:59:59";
            return DateUtils.strToDate(dateStrEnd);
        } else {
            return null;
        }
    }
    
    /**
     * 判断时间格式
     *
     * @param  date
     * @return
     */
    public static String getDatetimeFormat(String date){
        date = date.trim();
        String a1 = "[0-9]{4}[0-9]{2}[0-9]{2}[0-9]{2}[0-9]{2}[0-9]{2}";// yyyyMMddHHmmss
        String a2 = "[0-9]{4}[0-9]{2}[0-9]{2}";// yyyyMMdd
        String a3 = "[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}";// yyyy-MM-dd HH:mm:ss
        String a4 = "[0-9]{4}-[0-9]{2}-[0-9]{2}";// yyyy-MM-dd
        String a5 = "[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}";// yyyy-MM-dd HH:mm
        String a6 = "[0-9]{2}/[0-9]{2}/[0-9]{2}";// MM/dd/yy
        String a7 = "[0-9]{4}/[0-9]{2}/[0-9]{2}";// yyyy/MM/dd
        String a8 = "[0-9]{4}";// yyyy
        boolean datea1 = Pattern.compile(a1).matcher(date).matches();
        
        if (datea1) {
            return "yyyyMMddHHmmss";
        }
        boolean datea2 = Pattern.compile(a2).matcher(date).matches();
        
        if (datea2) {
            return FORMART_yyyyMMdd;
        }
        boolean datea3 = Pattern.compile(a3).matcher(date).matches();
        
        if (datea3) {
            return "yyyy-MM-dd HH:mm:ss";
        }
        boolean datea4 = Pattern.compile(a4).matcher(date).matches();
        
        if (datea4) {
            return "yyyy-MM-dd";
        }
        boolean datea5 = Pattern.compile(a5).matcher(date).matches();
        
        if (datea5) {
            return "yyyy-MM-dd HH:mm";
        }
        boolean datea6 = Pattern.compile(a6).matcher(date).matches();
        
        if (datea6) {
            return "MM/dd/yy";
        }
        boolean datea7 = Pattern.compile(a7).matcher(date).matches();
        
        if (datea7) {
            return "yyyy/MM/dd";
        }
        boolean datea8 = Pattern.compile(a8).matcher(date).matches();
        
        if (datea8) {
            return "yyyy";
        }
        return "";
    }
    
    /**
     * 获取相差的月数
     *
     * @param  date1
     * @param  date2
     * @return
     * @throws ParseException
     */
    public static int getMonthSpace(String date1, String date2){
        int result = 0;
        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();
        
        c1.setTime(parseDate(date1));
        c2.setTime(parseDate(date2));
        
        result = c2.get(Calendar.MONTH) - c1.get(Calendar.MONTH);
        
        return result == 0 ? 1 : Math.abs(result);
    }
    
    /**
     * 根据给的时间获取此月的最后一天 传入参数为String，可传入：1、"201807"；2、"2018-07-01"
     *
     * @param  date 账期
     * @return      String 当月的最后一天
     */
    public static String getLastDayByMonth(String date){
        Date d = parseDate(date, "yyyy-MM-dd");
        Calendar cal = Calendar.getInstance();
        cal.setTime(d);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
        return new SimpleDateFormat("yyyy-MM-dd ").format(cal.getTime());
    }
    
    /**
     * 根据给的时间获取此月的第一天 传入参数为String，可传入：1、"201807"；2、"2018-07-01"
     *
     * @param  date 账期
     * @return      String 当月的第一天
     */
    public static String getFirstDayByMonth(String date){
        Date d = parseDate(date, "yyyy-MM-dd");
        Calendar cal = Calendar.getInstance();
        cal.setTime(d);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMinimum(Calendar.DATE));
        return new SimpleDateFormat("yyyy-MM-dd ").format(cal.getTime());
    }
    
    /**
     * 获取过去7天内的日期数组
     *
     * @param  intervals intervals天内
     * @return           日期数组
     */
    public static ArrayList<String> getDays(int intervals){
        ArrayList<String> pastDaysList = new ArrayList<>();
        
        for (int i = intervals - 1; i >= 0; i--) {
            pastDaysList.add(getPastDate(i));
        }
        return pastDaysList;
    }
    
    /**
     * 获取过去第几天的日期
     *
     * @param  past
     * @return
     */
    public static String getPastDate(int past){
        return getPastDate(past, FORMART_DATE);
    }
    
    /**
     * 获取过去第几天的日期
     *
     * @param  past
     * @return
     */
    public static String getPastDate(int past, String sdf){
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) - past);
        Date today = calendar.getTime();
        SimpleDateFormat format = new SimpleDateFormat(sdf);
        String result = format.format(today);
        return result;
    }
    
    public static int daysBetween(Date early, Date late){
        
        java.util.Calendar calst = java.util.Calendar.getInstance();
        java.util.Calendar caled = java.util.Calendar.getInstance();
        calst.setTime(early);
        caled.setTime(late);
        // 设置时间为0时
        calst.set(java.util.Calendar.HOUR_OF_DAY, 0);
        calst.set(java.util.Calendar.MINUTE, 0);
        calst.set(java.util.Calendar.SECOND, 0);
        caled.set(java.util.Calendar.HOUR_OF_DAY, 0);
        caled.set(java.util.Calendar.MINUTE, 0);
        caled.set(java.util.Calendar.SECOND, 0);
        // 得到两个日期相差的天数
        int days = ((int) (caled.getTime().getTime() / 1000) - (int) (calst.getTime().getTime() / 1000)) / 3600 / 24;
        
        return days;
    }
    
    /**
     * 获取当前时间的前n小时的时间戳
     *
     * @return
     */
    public static long currentBeforeTime(int hour){
        long time = 0l;
        
        try {
            Calendar date = Calendar.getInstance();
            date.setTime(new Date());
            date.set(Calendar.HOUR_OF_DAY, date.get(Calendar.HOUR_OF_DAY) - hour);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
            String nowTime = sdf.format(date.getTime());
            time = sdf.parse(nowTime).getTime();
        } catch (ParseException e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        return time;
    }
    
    /**
     * 获取Timestamp时间
     *
     * @return
     */
    public static Timestamp getTimestamp(){
        return new Timestamp(Calendar.getInstance().getTimeInMillis());
    }
    
    /**
     * 获取明天时间
     *
     * @return
     */
    public static String getTomorrowTime(){
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DAY_OF_MONTH, 1);
        return format.format(calendar.getTime());
    }
    
    /**
     * 获取传入时间小时段区间
     *
     * @return
     */
    public static String getHourInterval(Date date){
        Calendar calendar = Calendar.getInstance();
        
        if (date != null) {
            calendar.setTime(date);
        }
        int hourStart = calendar.get(Calendar.HOUR_OF_DAY);
        int hourEnd = hourStart + 1;
        String hourStartStr = (hourStart > 9 ? "" + hourStart : "0" + hourStart) + ":00";
        String hourEndStr = (hourEnd > 9 ? "" + hourEnd : "0" + hourEnd) + ":00";
        return hourStartStr + "-" + hourEndStr;
    }
    
    /**
     * 当前时间的es日期字符串格式。yyyy-MM-dd'T'HH:mm:ss
     *
     * @param
     * @return
     */
    public static String esNowStr(){
        return esDateStr(new Date());
    }
    
    /**
     * 日期转成es的日期字符串格式。yyyy-MM-dd'T'HH:mm:ss
     *
     * @param  date
     * @return
     */
    public static String esDateStr(Date date){
        
        if (null == date) {
            return null;
        }
        
        SimpleDateFormat format = new SimpleDateFormat(UTC_ZONE_FORMATER);
        
        try {
            return format.format(date);
        } catch (Exception e) {
            return null;
        }
    }
    
    /**
     * 日期字符串转成es 日期字符串格式
     *
     * @param  dateStr
     * @return
     */
    public static String esDateStr(String dateStr){
        return esDateStr(dateStr, FORMART_FULL);
    }
    
    /**
     * 日期字符串 转成es 日期字符串格式
     *
     * @param  dateStr
     * @param  format
     * @return
     */
    public static String esDateStr(String dateStr, String format){
        
        Date date = parseDate(dateStr, format);
        
        return esDateStr(date);
    }
    
    /**
     * 判断日期是否是周六日
     * 
     * @param  date
     * @return      true 是 false 不是
     */
    public static Boolean getDateSaturdayAndSunday(Date date){
        
        if (date == null) {
            return null;
        }
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        
        if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY || cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
            return true;
        } else {
            return false;
        }
    }
    
    /**
     * 今天 昨天
     * 
     * @param  startDate
     * @return
     */
    public static String getDayTime(Date startDate){
        
        if (startDate == null) {
            return null;
        }
        Calendar cal = Calendar.getInstance();
        cal.setTime(startDate);
        int offSet = Calendar.getInstance().getTimeZone().getRawOffset();
        long today = (System.currentTimeMillis() + offSet) / 86400000;
        long start = (startDate.getTime() + offSet) / 86400000;
        long poor = start - today;
        
        if (poor == 0) {
            return ResultStatus.TODAY.getMsg() + "  " + formatDate(startDate, "HH:mm:ss");
        } else if (poor == -1) {
            return ResultStatus.YESTERDAY.getMsg() + "  " + formatDate(startDate, "HH:mm:ss");
        } else if (LocalDateTime.now().getYear() == cal.get(Calendar.YEAR)) {
            return formatDate(startDate, "MM-dd HH:mm:ss");
        } else {
            return formatDate(startDate, "YYYY-MM-dd HH:mm:ss");
        }
    }
    
    /**
     * 获取两个日期之间的所有日期集合
     * @param  startTime
     * @param  endTime
     * @param  isEnd     true包含结束时间，false不包含结束时间
     * @return
     */
    public static List<String> getBetweenDates(String startTime, String endTime, Boolean isEnd){
        
        // 返回的日期集合
        List<String> days = new ArrayList<String>();
        DateFormat dateFormat = new SimpleDateFormat(FORMART_yyyyMMdd);
        
        try {
            Date start = dateFormat.parse(startTime);
            Date end = dateFormat.parse(endTime);
            
            Calendar tempStart = Calendar.getInstance();
            tempStart.setTime(start);
            
            Calendar tempEnd = Calendar.getInstance();
            tempEnd.setTime(end);
            
            if (isEnd) {
                tempEnd.add(Calendar.DATE, +1);// 日期加1(包含结束)
            }
            
            while (tempStart.before(tempEnd)) {
                days.add(dateFormat.format(tempStart.getTime()));
                tempStart.add(Calendar.DAY_OF_YEAR, 1);
            }
            
        } catch (ParseException e) {
            log.info(e, " 异常：{}", e.getMessage());
        }
        
        return days;
    }
    
    /**
     * 将日期时间字符串转Timestamp对象
     * 
     * 空字符串或者格式错误的字符串，返回null
     * 
     * @param  timeStr 传入的日期字符串
     * @return         解析后的Timestamp对象
     */
    public static Timestamp parseTimestamp(String timeStr){
        
        if (StringUtils.isBlank(timeStr)) {
            return null;
        }
        
        Date date = parseDate(timeStr);
        
        if (null == date) {
            return null;
        }
        
        return new Timestamp(date.getTime());
    }

    public static String getDistanceTime(String dt, long offset){
        Date date = parseDate(dt);
        long dtl = 0;
        if (date != null) {
            dtl = date.getTime();
        } else {
            log.warn("时间字符串解析失败");
        }
        long rdtl = dtl + offset;
        return formatDate(new Date(rdtl), FORMART_FULL);
    }
}