日期常用的方法

package com.huawei.tool.utils;

import com.google.common.base.Strings;
import com.huawei.tool.constants.AssemblePipelineConst;
import com.huawei.tool.constants.CommonConst;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.DayOfWeek;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
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;

/**
 * Created by x00414327 on 2017/11/27.
 */
public class DateUtil {

    private static final Logger LOGGER = LoggerFactory.getLogger(DateUtil.class);

    //日期格式 包含时分秒
    public static final String longDateFormat = "yyyy/MM/dd HH:mm:ss";
    //日期格式 只有年月日
    public static final String shortDateFormat = "yyyy/MM/dd";

    public static final String shortDayFormat = "yyyy-MM-dd";
    //日期格式 只有年月日 小时分秒补0
    public static final String longDateFormatHourZero = "yyyy/MM/dd 00:00:00";

    public static final String DATE_FULL_STR = "yyyy-MM-dd HH:mm:ss";
    //带TZ的时间
    public static final String TIME_FORMAT_TZ = "yyyy-MM-dd'T'HH:mm:ss'Z'";

    StringUtil stringUtil = new StringUtil();

    /**
     * 获取两个日期之间的日期
     */
    public List<String> getBetweenDates(String stareDate, String endDate) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        List<String> result = new ArrayList<String>();

        Date start = stringUtil.convertStringToDate(stareDate);
        Calendar tempStart = Calendar.getInstance();
        tempStart.setTime(start);

        Date end = stringUtil.convertStringToDate(endDate);
        Calendar tempEnd = Calendar.getInstance();
        tempEnd.setTime(end);

        while (tempStart.before(tempEnd)) {
            String date = sdf.format(tempStart.getTime());
            result.add(date);
            tempStart.add(Calendar.DAY_OF_YEAR, 1);
        }
        result.add(sdf.format(tempStart.getTime()));
        return result;
    }

    /**
     * 根据传入的俩个时间/差值类型到秒
     *
     * @param startDateStr
     * @param endDateStr
     * @return
     * @throws ParseException
     */
    public static double diffBetweenTime(String startDateStr, String endDateStr) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Date startDate = null;
        Date endDate = null;
        try {
            startDate = sdf.parse(startDateStr);
            endDate = sdf.parse(endDateStr);
        } catch (ParseException e) {
            e.printStackTrace();
            return 0;
        }

        Calendar cal = Calendar.getInstance();
        cal.setTime(startDate);
        long time1 = cal.getTimeInMillis();
        cal.setTime(endDate);
        long time2 = cal.getTimeInMillis();
        double betweens = (double) (time2 - time1) / (1000);

        //保留俩位小数，并以字符形式返回
        return betweens;
    }

    public static String getToday() {
        Date now = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        String today = dateFormat.format(now);
        return today;
    }

    public static String getTodayAfterN(int n, String format) {
        Date now = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(now);
        calendar.add(Calendar.DAY_OF_MONTH, n);
        String todayAfterN = dateFormat.format(calendar.getTime());
        return todayAfterN;
    }

    /*
     * 根据起始时间和消耗时间计算结束时间
     */
    public static String addHms2Date(String start, String cost) {
        String ret = null;
        DateFormat dateformatEx = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        if (Strings.isNullOrEmpty(cost) || !cost.contains(":")) {
            return start;
        }
        try {
            Date sDate = dateformatEx.parse(start);
            String[] sfmArray = cost.split(":");
            if (sfmArray.length != 3) {
                return start;
            }
            String hh = sfmArray[0];
            int hour = Integer.parseInt(hh);
            String mm = sfmArray[1];
            int minute = Integer.parseInt(mm);
            String ss = sfmArray[2];
            int seconds = Integer.parseInt(ss);

            Calendar calendar = Calendar.getInstance();
            calendar.setTime(sDate);
            calendar.add(Calendar.HOUR, hour);
            calendar.add(Calendar.MINUTE, minute);
            calendar.add(Calendar.SECOND, seconds);
            Date outDate = calendar.getTime();
            ret = getFormatTime(outDate, DATE_FULL_STR);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ret;
    }

    public static String getFormatTime(Date date, String type) {
        SimpleDateFormat df = new SimpleDateFormat(type);
        return df.format(date);
    }

    /**
     * 获取系统当前时间
     */
    public static String getNowTime(String type) {
        SimpleDateFormat df = new SimpleDateFormat(type);
        return df.format(new Date());
    }

    /**
     * 获取当前日期所在周的第一天
     *
     * @param date      当前日期
     * @param formatter 日期格式化对象,只能含有日期信息，如：yyyy-MM-dd
     * @return 格式化后的日期字符串
     */
    public static String getFirstDayDateOfWeek(LocalDate date, DateTimeFormatter formatter) {
        DayOfWeek dayOfWeek = date.getDayOfWeek();
        while (dayOfWeek != DayOfWeek.SUNDAY) {
            date = date.plusDays(-1);
            dayOfWeek = date.getDayOfWeek();
        }
        return date.format(formatter);
    }


    /**
     * 获取日期是本年第几周
     *
     * @param year  年数
     * @param month 月数 1-12
     * @param day   当月第几天
     * @return 本年第几周
     */
    public static int getWeekOfYear(int year, int month, int day) {
        Calendar cal = Calendar.getInstance();
        cal.set(year, month - 1, day);
        return cal.get(Calendar.WEEK_OF_YEAR);
    }

    /**
     * 获取日期是本年第几周
     *
     * @param date 日期
     * @return 本年第几周
     */
    public static int getWeekOfYear(LocalDate date) {
        Calendar cal = Calendar.getInstance();
        cal.set(date.getYear(), date.getMonthValue() - 1, date.getDayOfMonth());
        return cal.get(Calendar.WEEK_OF_YEAR);
    }

    /**
     * 获取日期是本年第几周
     *
     * @param text 日期字符串，只包含日期信息  如：yyyy-MM-dd
     * @return 本年第几周
     */
    public static int getWeekOfYear(String text) {
        LocalDate date = LocalDate.parse(text);
        return getWeekOfYear(date);
    }

    /**
     * 获取十二个时间点（日、周、月）,从当前时间往前推
     *
     * @param dateType
     * @return
     */
    public static List<String> getTwelveDatePoint(String dateType) {
        LocalDate date = LocalDate.now();
        return getTwelveDatePoint(dateType,date);
    }

    /**
     * 获取十二个时间点（日、周、月）,从指定时间往前推
     * @param dateType 需要获取的返回日期类型
     * @param dateTime 指定时间字符串
     * @param dateFormat 时间格式字符串，如“yyyy-MM-dd HH:mm:ss”
     * @return 若dateTime或dateFormat为空，则返回从当前时间往前推的时间点集合
     */
    public static List<String> getTwelveDatePoint(String dateType,String dateTime,String dateFormat) {
        if(StringUtil.isEmpty(dateTime) || StringUtil.isEmpty(dateFormat)){
            return getTwelveDatePoint(dateType);
        }
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(dateFormat);
        LocalDate date = LocalDate.parse(dateTime,formatter);
        return getTwelveDatePoint(dateType, date);
    }

    /**
     * 获取十二个时间点（日、周、月）,从指定时间（LocalDate）往前推
     * @param dateType
     * @param date
     * @return
     */
    private static List<String> getTwelveDatePoint(String dateType, LocalDate date) {
        ChronoUnit unit = null;
        switch (dateType.toLowerCase()) {
            case CommonConst.STATISTICS_BY_DAY:
                unit = ChronoUnit.DAYS;
                break;
            case CommonConst.STATISTICS_BY_MONTH:
                unit = ChronoUnit.MONTHS;
                break;
            case CommonConst.STATISTICS_BY_WEEK:
                unit = ChronoUnit.WEEKS;
                break;
            default:
                unit = ChronoUnit.DAYS;
                break;
        }
        List<String> datePointList = new ArrayList<>();
        for (int i = 0; i < AssemblePipelineConst.LIMIT_NUMBER; i++) {
            String datePoint = getDatePoint(date, dateType);
            datePointList.add(datePoint);
            date = date.minus(1, unit);
        }
        return datePointList;
    }

    /**
     * 获取日、周、月时间点
     *
     * @param date
     * @param dateType
     * @return
     */
    public static String getDatePoint(LocalDate date, String dateType) {
        String result = null;
        switch (dateType.toLowerCase()) {
            case CommonConst.STATISTICS_BY_DAY:
                result = date.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
                break;
            case CommonConst.STATISTICS_BY_MONTH:
                result = date.format(DateTimeFormatter.ofPattern("yyyy-MM"));
                break;
            case CommonConst.STATISTICS_BY_WEEK:
                LocalDate firstDayDateOfWeek=getFirstDayOfWeek(date);
                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM.dd");
                result = firstDayDateOfWeek.format(formatter) + "~" + firstDayDateOfWeek.plusDays(6).format(formatter);
                break;
        }
        return result;
    }

    /**
     * 根据格式化日期获取时间点信息
     * @param formatDate 格式化日期，2018-01-01/2018-01/2018-34这种格式
     * @param dateType 时间点2018-01-01/2018-01/10.21-10.27这种格式
     * @return
     */
    public static String getDatePoint(String formatDate, String dateType) {
        switch (dateType) {
            case CommonConst.STATISTICS_BY_DAY:
            case CommonConst.STATISTICS_BY_MONTH:
                return formatDate;
            case CommonConst.STATISTICS_BY_WEEK:
                Calendar cal = Calendar.getInstance();
                cal.setFirstDayOfWeek(Calendar.MONDAY);
                cal.setMinimalDaysInFirstWeek(4);
                cal.set(Calendar.YEAR, Integer.parseInt(formatDate.substring(0, 4)));
                cal.set(Calendar.WEEK_OF_YEAR, Integer.parseInt(formatDate.substring(5, formatDate.length())));
                LocalDate localDate = cal.getTime().toInstant().atOffset(ZoneOffset.of("+8")).toLocalDate();
                return getDatePoint(localDate, dateType);
            default:
                return null;
        }
    }

    /**
     * 获取当前日期所在周的第一天
     * @param date 当前日期
     * @return 格式化后的日期字符串
     */
    public static LocalDate getFirstDayOfWeek(LocalDate date) {
        DayOfWeek dayOfWeek = date.getDayOfWeek();
        while(dayOfWeek!=DayOfWeek.MONDAY){
            date=date.plusDays(-1);
            dayOfWeek=date.getDayOfWeek();
        }
        return date;
    }

    /**
     * 根据时间戳返回时间点，时间点是月，周，日的时间
     * @param dateType 日期类型，day，week，month
     * @param timestamp 时间毫秒值
     * @return 时间点2018-01-01/2018-01/10.21-10.27这种格式
     */
    public static String getDatePointByTimestamp(String dateType, long timestamp) {
        LocalDate localDate = Instant.ofEpochMilli(timestamp).atOffset(ZoneOffset.of("+8")).toLocalDate();

        return getDatePoint(localDate,dateType);
    }

    /**
     * 计算日期差
     * *计算两个日期差，可以选择精确到小时
     */
    public static double getDateTimeDiffByHour(String dateStr1, String dateStr2) {
        double result = 0;
        if(StringUtil.isEmpty(dateStr1)){
           return  0;
        }
        if(StringUtil.isEmpty(dateStr2)){
           return  0;
        }
        //验证输入日期的格式是否正确
        if (!isRightDateStr(dateStr1, "yyyy-MM-dd HH:mm:ss") || !isRightDateStr(dateStr2, "yyyy-MM-dd HH:mm:ss")) {
            return 0;
        }
        DateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//日期字符串格式
        try {
            Date date1 = dateformat.parse(dateStr1);
            Date date2 = dateformat.parse(dateStr2);
            double datediff = date1.getTime() - date2.getTime();//得到的差值是微秒级别
            result = Math.abs(datediff / (1000 * 60 * 60));
            return result;
        } catch (ParseException e) {
            e.printStackTrace();
            return 0;
        }
    }

    /*验证日期格式是否正确
     *
     */
    public static boolean isRightDateStr(String dateStr, String datePattern) {
        DateFormat dateFormat = new SimpleDateFormat(datePattern);
        try {
            //采用严格的解析方式，防止类似 “2017-05-35” 类型的字符串通过
            dateFormat.setLenient(false);
            dateFormat.parse(dateStr);
            Date date = (Date) dateFormat.parse(dateStr);
            //重复比对一下，防止类似 “2017-5-15” 类型的字符串通过
            String newDateStr = dateFormat.format(date);
            return  dateStr.equals(newDateStr);
        } catch (ParseException e) {
        }
            return false;
    }

    /**
     * 通过当前日期获取对应的月的第一天，周的第一天，日的第一天
     */
    public static String[] getFirstAndNowDay(String staticType) {

        String [] result=new String[2];
        //格式化日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date nowDate = new Date();
        String now = sdf.format(nowDate);
        String resultDay =null;
        Calendar cal = Calendar.getInstance();
        if (CommonConst.STATISTICS_BY_MONTH.equals(staticType)) {
            int month = Integer.parseInt(String.valueOf(nowDate.getMonth()));
            //设置前12个月
            cal.set(Calendar.MONTH, month - 11);
            //设置日历中月份的第1天
            cal.set(Calendar.DAY_OF_MONTH, 1);
            resultDay = sdf.format(cal.getTime());
        } else if (CommonConst.STATISTICS_BY_DAY.equals(staticType)) {
            cal.add(Calendar.DATE, -11);
            resultDay = sdf.format(cal.getTime());
        } else {
            cal.add(Calendar.DATE, -11 *7);
            cal.set(Calendar.DAY_OF_WEEK,Calendar.MONDAY);
            resultDay = sdf.format(cal.getTime());
        }
         result[0] = resultDay;
         result[1] = now;
         return result;
    }

    /**
     * 根据插入的日期，查询日期在对应日期类型中起始日期
     * @param TimePara
     * @param statisticsType
     * @return
     */
    public static String[] getFirstAndLastDay(String TimePara, String statisticsType) {

        String[] result = new String[2];
        Calendar c = new GregorianCalendar();
        //格式化日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String startDay = null;
        String endDay = null;
        if(StringUtil.isEmpty(TimePara)){
           return null;
        }
        String [] timeArray = TimePara.split("-");
        int year = Integer.parseInt(timeArray[0]);
        int monthOrWeek = Integer.parseInt(timeArray[1]);
        if (CommonConst.STATISTICS_BY_MONTH.equals(statisticsType)) {
              startDay = String.valueOf(sdf.format(getBeginTime(year,monthOrWeek)));
              endDay =  String.valueOf(sdf.format(getEndTime(year,monthOrWeek)));
        } else if (CommonConst.STATISTICS_BY_DAY.equals(statisticsType)) {
              startDay = TimePara;
              endDay = TimePara;
        } else {
            c.set(Calendar.YEAR, year);
            c.set(Calendar.MONTH, Calendar.JANUARY);
            c.set(Calendar.DATE, 1);
            Calendar cal = (GregorianCalendar) c.clone();
            cal.add(Calendar.DATE, (monthOrWeek-1) * 7);
            startDay = String.valueOf(sdf.format(getFirstDayOfWeek(cal.getTime())));
            endDay  = String.valueOf(sdf.format(getLastDayOfWeek(cal.getTime())));
        }
            result[0] = startDay;
            result[1] = endDay;
        return result;
    }

    // 获取当前时间所在周的开始日期
    public static Date getFirstDayOfWeek(Date date) {
        Calendar c = new GregorianCalendar();
        c.setFirstDayOfWeek(Calendar.MONDAY);
        c.setTime(date);
        c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday
        return c.getTime();
    }

    // 获取当前时间所在周的结束日期
    public static Date getLastDayOfWeek(Date date) {
        Calendar c = new GregorianCalendar();
        c.setFirstDayOfWeek(Calendar.MONDAY);
        c.setTime(date);
        c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6); // Sunday
        return c.getTime();
    }
     public static Date getBeginTime(int year, int month) {
        YearMonth yearMonth = YearMonth.of(year, month);
        LocalDate localDate = yearMonth.atDay(1);
        LocalDateTime startOfDay = localDate.atStartOfDay();
        ZonedDateTime zonedDateTime = startOfDay.atZone(ZoneId.of("Asia/Shanghai"));

        return Date.from(zonedDateTime.toInstant());
    }

    public static Date getEndTime(int year, int month) {
        YearMonth yearMonth = YearMonth.of(year, month);
        LocalDate endOfMonth = yearMonth.atEndOfMonth();
        LocalDateTime localDateTime = endOfMonth.atTime(23, 59, 59, 999);
        ZonedDateTime zonedDateTime = localDateTime.atZone(ZoneId.of("Asia/Shanghai"));
        return Date.from(zonedDateTime.toInstant());
    }

    /**
     * 获取当前月的第一天，周的第一天，日的第一天
     */
    public static List<String> getCurrentMonthWeekDayDate(String format) {
        List<String> result=new ArrayList<>();
        LocalDateTime localDateTime = LocalDateTime.now().withHour(0).withMinute(0).withSecond(0).withNano(0);
        //当天
        result.add(localDateTime.format(DateTimeFormatter.ofPattern(format)));
        //当周
        result.add(localDateTime.minusDays(localDateTime.getDayOfWeek().getValue()-1).format(DateTimeFormatter.ofPattern(format)));
        //当月
        result.add(localDateTime.minusDays(localDateTime.getDayOfMonth()-1).format(DateTimeFormatter.ofPattern(format)));
        return result;
    }

    /**
     * 根据类型获取当前周期的起始时间
     * @param format
     * @param statisticsType
     * @return
     */
    public static String getCurrentPeriodStartTime(String format,String statisticsType){
        List<String> times = DateUtil.getCurrentMonthWeekDayDate(format);

        if (CommonConst.STATISTICS_BY_MONTH.equals(statisticsType)) {
            return times.get(2);
        }
        if (CommonConst.STATISTICS_BY_WEEK.equals(statisticsType)) {
            return times.get(1);
        }
        return times.get(0);
    }

    /**
     * 获取近三天日期
     *
     * @return
     */
    public static List<String> getLatestFourDay() {
        List<String> result = new ArrayList<>();
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat(shortDayFormat);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);

        calendar.add(Calendar.DAY_OF_MONTH, -2);
        date = calendar.getTime();
        result.add(sdf.format(date));

        calendar.add(Calendar.DAY_OF_MONTH, 1);
        date = calendar.getTime();
        result.add(sdf.format(date));

        calendar.add(Calendar.DAY_OF_MONTH, 1);
        date = calendar.getTime();
        result.add(sdf.format(date));

        calendar.add(Calendar.DAY_OF_MONTH, 1);
        date = calendar.getTime();
        result.add(sdf.format(date));

        return result;
    }
}