时间日期各种工具类

package com.panchan.m2.utils;

import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
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.SimpleTimeZone;
import java.util.TimeZone;

import org.apache.commons.lang3.StringUtils;


public abstract class DateUtils {
     public static final String dateFmt = "yyyy-MM-dd hh:mm:ss.SSS";
     
      public static String getTime()
      {
        return formatCurrentDate("yyyy-MM-dd HH:mm:ss");
      }

      public static String getTime(String format)
      {
        return formatCurrentDate(format);
      }

      public static String getCurrentDate()
      {
        return formatCurrentDate("yyyyMMdd");
      }

      public static String getCurrentDate(String format)
      {
        return formatCurrentDate(format);
      }

      public static String getThisMonth()
      {
        return formatCurrentDate("yyyyMM");
      }

      public static String getThisYear()
      {
        return formatCurrentDate("yyyy");
      }

      public static String getCurrentTime()
      {
        return formatCurrentDate("HHmmss");
      }

      public static String getDayInterval(String format, int distance)
      {
        Calendar calendar = getCalendar();
        calendar.roll(5, distance);
        return format(calendar.getTime(), format);
      }

      public static String getDayInterval(String dateString, String format, int distance)
      {
        Calendar calendar = getCalendar(dateString);
        calendar.roll(5, distance);
        return format(calendar, format);
      }

      public static String getYesterday()
      {
        Calendar calendar = getCalendar();
        calendar.roll(5, -1);
        return format(calendar, "yyyy/MM/dd");
      }

      public static String getLastMonth()
      {
        Calendar calendar = getCalendar();
        calendar.roll(2, -1);
        return format(calendar, "yyyy/MM");
      }

      public static String[] getDates(String startDay, String endDay)
      {
        List dates = new ArrayList();
        dates.add(startDay);
        Calendar cal = getCalendar();
        cal.setTime(string2Date(startDay));
        for (String nextDay = date2String(cal.getTime()); !nextDay.equals(endDay); dates.add(nextDay))
        {
          cal.add(5, 1);
          nextDay = date2String(cal.getTime());
        }

        return (String[])dates.toArray(new String[0]);
      }

      public static Calendar getCalendar()
      {
        return getCalendar(new Date());
      }

      public static Calendar getCalendar(String dateString)
      {
        return getCalendar(string2Date(dateString, "yyyyMMdd"));
      }

      public static Calendar getCalendar(Date date)
      {
        Calendar calendar = new GregorianCalendar(TimeZone.getDefault(), Locale.getDefault());
        calendar.setTime(date);
        return calendar;
      }

      public static String date2String(Date d)
      {
        return date2String(d, "yyyyMMddhhmmss");
      }

      public static String date2String(Date date, String format)
      {
        return format(date, format);
      }

      public static Date string2Date(String s)
      {
        return string2Date(s, "yyyyMMddhhmmss");
      }

      public static Date string2Date(String dateString, String format)
      {
        return parseDate(dateString, format);
      }

      public static long getDayDistance(String startDate, String endDate)
        throws Exception
      {
        return getDayDistance(startDate, endDate, null);
      }

      public static long getDayDistance(String startDate, String endDate, String format)
        throws Exception
      {
        if (format == null) {
          format = "yyyyMMdd";
        }

        long day2day = 0L;
        Date sDate = parseDate(startDate, format);
        Date eDate = parseDate(endDate, format);
        day2day = (eDate.getTime() - sDate.getTime()) / 86400000L;

        return Math.abs(day2day);
      }

      public static String getUSTime()
      {
        DateFormat dateFormat = createDateFormat("EEE, d MMM yyyy HH:mm:ss z", Locale.US);
        dateFormat.setTimeZone(new SimpleTimeZone(0, "GMT"));
        return dateFormat.format(new Date());
      }

      public static String getCurrentday()
      {
        Calendar calendar = getCalendar();
        calendar.roll(5, 0);
        return format(calendar, "yyyy-MM-dd");
      }

      public static String convertFormat(String dateData)
      {
        return convertFormat(dateData, "yyyy-MM-dd");
      }

      public static String convertFormat(String dateData, String format)
      {
        return convertToString(convertToTimestamp(dateData), format);
      }

      public static Timestamp getCurrentTimeStamp()
      {
        return new Timestamp(getCalendar().getTime().getTime());
      }

      public static String convertToString(Timestamp dateData)
      {
        return convertToString(dateData, "yyyy/MM/dd");
      }

      public static String convertToString(Timestamp dateData, String pattern)
      {
        if (dateData == null)
        {
          return null;
        }
        return format(dateData, pattern);
      }

      public static Timestamp convertToTimestamp(String dateData)
      {
        if (StringUtils.isBlank(dateData)) {
          return null;
        }
        String yearString = dateData.substring(0, 4);
        String monthString = dateData.substring(4, 6);
        String dayString = dateData.substring(6, 8);
        int year = Integer.parseInt(yearString);
        int month = Integer.parseInt(monthString) - 1;
        int day = Integer.parseInt(dayString);

        Calendar cal = getCalendar();
        cal.set(year, month, day);
        cal.getTime();
        return new Timestamp(cal.getTime().getTime());
      }

      public static Date check(String dateData)
        throws ParseException
      {
        return check(dateData, "yyyyMMdd");
      }

      public static Date check(String dateString, String format)
        throws ParseException
      {
        if (dateString == null)
          throw new ParseException("date string to check is null", 0);
        if (format == null) {
          throw new ParseException("format string to check date is null", 0);
        }
        Date date = parseDate(dateString, format);
        if (!format(date, format).equals(dateString)) {
          throw new ParseException("Out of bound date:"" + dateString + "" with format "" + format + """, 0);
        }
        return date;
      }

      public static boolean isValid(String dateData)
        throws Exception
      {
        return isValid(dateData, "yyyyMMdd");
      }

      public static boolean isValid(String s, String format)
      {
        SimpleDateFormat formatter = new SimpleDateFormat(format, Locale.KOREA);
        Date date = null;
        try
        {
          date = formatter.parse(s);
        }
        catch (ParseException e)
        {
          return false;
        }
        return formatter.format(date).equals(s);
      }

      public static String getDateString()
      {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd", Locale.KOREA);
        return formatter.format(new Date());
      }

      public static int getDay()
      {
        return getNumberByPattern("dd");
      }

      public static int getYear()
      {
        return getNumberByPattern("yyyy");
      }

      public static int getMonth()
      {
        return getNumberByPattern("MM");
      }

      public static int getNumberByPattern(String pattern)
      {
        return Integer.parseInt(formatCurrentDate(pattern));
      }

      public static String getFormatString(String pattern)
      {
        return formatCurrentDate(pattern);
      }

      public static String getShortDateString()
      {
        return formatCurrentDate("yyyyMMdd");
      }

      public static String getShortTimeString()
      {
        return formatCurrentDate("HHmmss");
      }

      public static String getTimeStampString()
      {
        return formatCurrentDate("yyyy-MM-dd-HH:mm:ss:SSS");
      }

      public static String getTimeString()
      {
        return formatCurrentDate("HH:mm:ss");
      }

      public static int whichDay(String s)
        throws ParseException
      {
        return whichDay(s, "yyyyMMdd");
      }

      public static int whichDay(String s, String format)
        throws ParseException
      {
        SimpleDateFormat formatter = new SimpleDateFormat(format, Locale.KOREA);
        Date date = check(s, format);
        Calendar calendar = formatter.getCalendar();
        calendar.setTime(date);
        return calendar.get(7);
      }

      public static int daysBetween(String from, String to)
        throws ParseException
      {
        return daysBetween(from, to, "yyyyMMdd");
      }

      public static int daysBetween(String from, String to, String format)
        throws ParseException
      {
        Date d1 = check(from, format);
        Date d2 = check(to, format);
        long duration = d2.getTime() - d1.getTime();
        return (int)(duration / 86400000L);
      }

      public static int ageBetween(String from, String to)
        throws ParseException
      {
        return ageBetween(from, to, "yyyyMMdd");
      }

      public static int ageBetween(String from, String to, String format)
        throws ParseException
      {
        return daysBetween(from, to, format) / 365;
      }

      public static String addDays(String s, int day)
        throws ParseException
      {
        return addDays(s, day, "yyyyMMdd");
      }

      public static String addDays(String s, int day, String format)
        throws ParseException
      {
        SimpleDateFormat formatter = new SimpleDateFormat(format, Locale.KOREA);
        Date date = check(s, format);
        date.setTime(date.getTime() + day * 1000L * 60L * 60L * 24L);
        return formatter.format(date);
      }

      public static String addMonths(String s, int month)
        throws Exception
      {
        return addMonths(s, month, "yyyyMMdd");
      }

      public static String addMonths(String s, int addMonth, String format)
        throws Exception
      {
        SimpleDateFormat formatter = new SimpleDateFormat(format, Locale.KOREA);
        Date date = check(s, format);
        SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy", Locale.KOREA);
        SimpleDateFormat monthFormat = new SimpleDateFormat("MM", Locale.KOREA);
        SimpleDateFormat dayFormat = new SimpleDateFormat("dd", Locale.KOREA);
        int year = Integer.parseInt(yearFormat.format(date));
        int month = Integer.parseInt(monthFormat.format(date));
        int day = Integer.parseInt(dayFormat.format(date));
        month += addMonth;
        if (addMonth > 0) {
          while (month > 12)
          {
            month -= 12;
            year++;
          }
        }
        while (month <= 0)
        {
          month += 12;
          year--;
        }
        DecimalFormat fourDf = new DecimalFormat("0000");
        DecimalFormat twoDf = new DecimalFormat("00");
        String tempDate = String.valueOf(fourDf.format(year)) + String.valueOf(twoDf.format(month)) + String.valueOf(twoDf.format(day));
        Date targetDate = null;
        try
        {
          targetDate = check(tempDate, "yyyyMMdd");
        }
        catch (ParseException pe)
        {
          day = lastDay(year, month);
          tempDate = String.valueOf(fourDf.format(year)) + String.valueOf(twoDf.format(month)) + String.valueOf(twoDf.format(day));
          targetDate = check(tempDate, "yyyyMMdd");
        }
        return formatter.format(targetDate);
      }

      public static String addYears(String s, int year)
        throws ParseException
      {
        return addYears(s, year, "yyyyMMdd");
      }

      public static String addYears(String s, int year, String format)
        throws ParseException
      {
        SimpleDateFormat formatter = new SimpleDateFormat(format, Locale.KOREA);
        Date date = check(s, format);
        date.setTime(date.getTime() + year * 1000L * 60L * 60L * 24L * 366L);
        return formatter.format(date);
      }

      public static int monthsBetween(String from, String to)
        throws ParseException
      {
        return monthsBetween(from, to, "yyyyMMdd");
      }

      public static int monthsBetween(String from, String to, String format)
        throws ParseException
      {
        Date fromDate = check(from, format);
        Date toDate = check(to, format);
        if (fromDate.compareTo(toDate) == 0)
          return 0;
        SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy", Locale.KOREA);
        SimpleDateFormat monthFormat = new SimpleDateFormat("MM", Locale.KOREA);
        SimpleDateFormat dayFormat = new SimpleDateFormat("dd", Locale.KOREA);
        int fromYear = Integer.parseInt(yearFormat.format(fromDate));
        int toYear = Integer.parseInt(yearFormat.format(toDate));
        int fromMonth = Integer.parseInt(monthFormat.format(fromDate));
        int toMonth = Integer.parseInt(monthFormat.format(toDate));
        int fromDay = Integer.parseInt(dayFormat.format(fromDate));
        int toDay = Integer.parseInt(dayFormat.format(toDate));
        int result = 0;
        result += (toYear - fromYear) * 12;
        result += toMonth - fromMonth;
        if (toDay - fromDay > 0)
          result += toDate.compareTo(fromDate);
        return result;
      }

      public static String lastDayOfMonth(String src)
        throws ParseException
      {
        return lastDayOfMonth(src, "yyyyMMdd");
      }

      public static String lastDayOfMonth(String src, String format)
        throws ParseException
      {
        SimpleDateFormat formatter = new SimpleDateFormat(format, Locale.KOREA);
        Date date = check(src, format);
        SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy", Locale.KOREA);
        SimpleDateFormat monthFormat = new SimpleDateFormat("MM", Locale.KOREA);
        int year = Integer.parseInt(yearFormat.format(date));
        int month = Integer.parseInt(monthFormat.format(date));
        int day = lastDay(year, month);
        DecimalFormat fourDf = new DecimalFormat("0000");
        DecimalFormat twoDf = new DecimalFormat("00");
        String tempDate = String.valueOf(fourDf.format(year)) + String.valueOf(twoDf.format(month)) + String.valueOf(twoDf.format(day));
        date = check(tempDate, format);
        return formatter.format(date);
      }

      private static int lastDay(int year, int month)
        throws ParseException
      {
        int day = 0;
        switch (month)
        {
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
        case 12:
          day = 31;
          break;
        case 2:
          if (year % 4 == 0)
          {
            if ((year % 100 == 0) && (year % 400 != 0))
              day = 28;
            else
              day = 29;
          }
          else {
            day = 28;
          }
          break;
        case 4:
        case 6:
        case 9:
        case 11:
        default:
          day = 30;
        }

        return day;
      }

      public static String format(long timeMillis, String format)
      {
        return format(new Date(timeMillis), format);
      }

      public static String format(Date date, Locale locale) {
        return DateFormat.getDateInstance(1, locale).format(date);
      }

      public static String formatCurrentDate(String format)
      {
        return createDateFormat(format).format(new Date());
      }

      public static String format(Date date, String format)
      {
        return createDateFormat(format).format(date);
      }

      public static String format(Calendar calendar, String format)
      {
        return format(calendar.getTime(), format);
      }

      public static String format(String dateString, String inFormat, String outFormat)
      {
        return format(parseDate(dateString, inFormat), outFormat);
      }

      public static String currdate(String format)
      {
        Calendar calendar = Calendar.getInstance();
        return format(calendar, format);
      }

      public static Date parseDate(String dateString, String format)
      {
        return new SimpleDateFormat(format).parse(dateString, new ParsePosition(0));
      }

      public static Calendar parseCalendar(String dateString, String format)
      {
        Date date = parseDate(dateString, format);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar;
      }

      public static int dateDiff(char c, Calendar calendar, Calendar calendar1)
      {
        if (c == 'y') {
          c = 'y';
        }
        else if (c == 'M') {
          c = 'M';
        }
        else if (c == 'h') {
          c = 'h';
        }
        else if (c == 'm') {
          c = 'm';
        }
        else if (c == 's')
          c = 's';
        else
          c = 'd';
        int i = calendar1.get(1);
        int j = calendar.get(1);
        int k = i - j;
        if (c == 'y')
          return k;
        int l = k * 12 + (calendar1.get(2) - calendar.get(2));
        if (c == 'M')
          return l;
        long l1 = calendar1.getTime().getTime();
        long l2 = calendar.getTime().getTime();
        long l3 = l1 - l2;
        if (c == 'h')
          return Long.valueOf(l3 / 3600000L).intValue();
        if (c == 'm')
          return Long.valueOf(l3 / 60000L).intValue();
        if (c == 's') {
          return Long.valueOf(l3 / 1000L).intValue();
        }
        return Long.valueOf(l3 / 86400000L).intValue();
      }

      public static int dateDiff(char c, Date date, Date date1)
      {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        Calendar calendar1 = Calendar.getInstance();
        calendar1.setTime(date1);
        return dateDiff(c, calendar, calendar1);
      }

      public static int dateDiff(char c, String s, String s1, String s2, String s3)
      {
        Calendar calendar = parseCalendar(s, s1);
        Calendar calendar1 = parseCalendar(s2, s3);
        return dateDiff(c, calendar, calendar1);
      }

      public static int dateDiff(char c, String s, String s1, String s2)
      {
        Calendar calendar = parseCalendar(s, s2);
        Calendar calendar1 = parseCalendar(s1, s2);
        return dateDiff(c, calendar, calendar1);
      }

      public static int dDay(char c, Calendar calendar)
      {
        Calendar calendar1 = Calendar.getInstance();
        return dateDiff(c, calendar1, calendar);
      }

      public static int dDay(char c, Date date)
      {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return dDay(c, calendar);
      }

      public static int dDay(char c, String s, String s1)
      {
        Calendar calendar = parseCalendar(s, s1);
        return dDay(c, calendar);
      }

      public static Calendar dateAdd(char c, int i, Calendar calendar)
      {
        Calendar calendar1 = calendar;
        if (c == 'y') {
          calendar1.add(1, i);
        }
        else if (c == 'M') {
          calendar1.add(2, i);
        }
        else if (c == 'h') {
          calendar1.add(11, i);
        }
        else if (c == 'm') {
          calendar1.add(12, i);
        }
        else if (c == 's')
          calendar1.add(13, i);
        else
          calendar1.add(5, i);
        return calendar1;
      }

      public static Date dateAdd(char c, int i, Date date)
      {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return dateAdd(c, i, calendar).getTime();
      }

      public static String dateAdd(char c, int i, String s, String s1)
      {
        Calendar calendar = parseCalendar(s, s1);
        return format(dateAdd(c, i, calendar), s1);
      }

      public static int getMonthlyDayCount(int i, int j)
      {
        byte byte0 = 0;
        if ((j == 4) || (j == 6) || (j == 9) || (j == 11)) {
          byte0 = 30;
        }
        else if (j == 2)
        {
          byte0 = 28;
          if (isYunYear(i))
            byte0 = 29;
        }
        else {
          byte0 = 31;
        }
        return byte0;
      }

      public static boolean isYunYear(int i)
      {
        boolean flag = false;
        if (i % 4 == 0) {
          if (i % 100 == 0)
          {
            if (i % 400 == 0)
              flag = true;
          }
          else
            flag = true;
        }
        return flag;
      }

      public static String dateFormatChange(String periodDate, String format) {
        String dateStr = "";

        String dateFormat1 = "";
        String dateFormat2 = "";
        if (format.equals("MMDDYYYY")) {
          dateFormat1 = "MMddyyyy";
          dateFormat2 = "MM-dd-yyyy";
        } else if (format.equals("MMYYYY")) {
          dateFormat1 = "MMyyyy";
          dateFormat2 = "MM-yyyy";
        } else {
          dateFormat1 = "yyyy";
          dateFormat2 = "yyyy";
        }
        dateStr = date2String(string2Date(periodDate, dateFormat1), dateFormat2);
        return dateStr;
      }

      public static boolean dateAfter(String input, String target)
      {
        Calendar inputCal = parseCalendar(input, "yyyyMMdd");
        Calendar targetCal = parseCalendar(target, "yyyyMMdd");
        return inputCal.after(targetCal);
      }

      private static DateFormat createDateFormat(String pattern) {
        return createDateFormat(pattern, Locale.getDefault());
      }

      private static DateFormat createDateFormat(String pattern, Locale locale) {
        return new SimpleDateFormat(pattern, locale);
      }

    /**
     * 日期格式化
     *
     * @param
     * @return
     * @author lishuai
     * @date 2018/12/24 19:34
     */
    public static String getDataFormat(Date dt) {
        if (dt != null) {
            return DateUtils.date2String(dt, "yyyy-MM-dd HH:mm:ss");
        } else {
            return "";
        }
    }


    }