1、日期格式化-工具类-One

  1. /**
  2.  * 日期工具类
  3.  */
  4. public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
  7.     private static String[] parsePatterns = {
  8.             "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
  9.             "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM",
  10.             "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"};
  12.     /**
  13.      * 得到当前日期字符串 格式（yyyy-MM-dd）
  14.      */
  15.     public static String getDate() {
  16.         return getDate("yyyy-MM-dd");
  17.     }
  19.     /**
  20.      * 得到当前日期字符串 格式（yyyy-MM-dd） pattern可以为："yyyy-MM-dd" "HH:mm:ss" "E"
  21.      */
  22.     public static String getDate(String pattern) {
  23.         return DateFormatUtils.format(new Date(), pattern);
  24.     }
  26.     /**
  27.      * 得到日期字符串 默认格式（yyyy-MM-dd） pattern可以为："yyyy-MM-dd" "HH:mm:ss" "E"
  28.      */
  29.     public static String formatDate(Date date, Object... pattern) {
  30.         String formatDate = null;
  31.         if (pattern != null && pattern.length > 0) {
  32.             formatDate = DateFormatUtils.format(date, pattern[0].toString());
  33.         } else {
  34.             formatDate = DateFormatUtils.format(date, "yyyy-MM-dd");
  35.         }
  36.         return formatDate;
  37.     }
  39.     /**
  40.      * 字符串转日期
  41.      * 默认格式（yyyy-MM-dd HH:mm:ss） pattern可以为："yyyy-MM-dd" "HH:mm:ss"
  42.      */
  43.     public static Date stringToDate(String string, String pattern) {
  44.         SimpleDateFormat sdf = null;
  45.         Date date = null;
  46.         try {
  47.             if (pattern != null && pattern.length() > 0) {
  48.                 sdf = new SimpleDateFormat(pattern);
  49.                 date = sdf.parse(string);
  50.             } else {
  51.                 sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  52.                 date = sdf.parse(string);
  53.             }
  54.         } catch (ParseException e) {
  55.             e.printStackTrace();
  56.         }
  57.         return date;
  58.     }
  60.     /**
  61.      * 得到日期时间字符串，转换格式（yyyy-MM-dd HH:mm:ss）
  62.      */
  63.     public static String formatDateTime(Date date) {
  64.         return formatDate(date, "yyyy-MM-dd HH:mm:ss");
  65.     }
  67.     /**
  68.      * 得到当前时间字符串 格式（HH:mm:ss）
  69.      */
  70.     public static String getTime() {
  71.         return formatDate(new Date(), "HH:mm:ss");
  72.     }
  74.     /**
  75.      * 得到当前日期和时间字符串 格式（yyyy-MM-dd HH:mm:ss）
  76.      */
  77.     public static String getDateTime() {
  78.         return formatDate(new Date(), "yyyy-MM-dd HH:mm:ss");
  79.     }
  81.     /**
  82.      * 得到当前年份字符串 格式（yyyy）
  83.      */
  84.     public static String getYear() {
  85.         return formatDate(new Date(), "yyyy");
  86.     }
  88.     /**
  89.      * 得到当前月份字符串 格式（MM）
  90.      */
  91.     public static String getMonth() {
  92.         return formatDate(new Date(), "MM");
  93.     }
  95.     /**
  96.      * 得到当天字符串 格式（dd）
  97.      */
  98.     public static String getDay() {
  99.         return formatDate(new Date(), "dd");
  100.     }
  102.     /**
  103.      * 得到当前星期字符串 格式（E）星期几
  104.      */
  105.     public static String getWeek() {
  106.         return formatDate(new Date(), "E");
  107.     }
  109.     /**
  110.      * 得到当前星期字符串 格式（E）星期几
  111.      *
  112.      * @param string
  113.      */
  114.     public static String getWeek(String string) {
  115.         return formatDate(stringToDate(string, ""), "E");
  116.     }
  118.     /**
  119.      * 日期型字符串转化为日期 格式
  120.      * { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm",
  121.      * "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm",
  122.      * "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm" }
  123.      */
  124.     public static Date parseDate(Object str) {
  125.         if (str == null) {
  126.             return null;
  127.         }
  128.         try {
  129.             return parseDate(str.toString(), parsePatterns);
  130.         } catch (ParseException e) {
  131.             return null;
  132.         }
  133.     }
  135.     /**
  136.      * 获取过去的天数
  137.      *
  138.      * @param date
  139.      * @return
  140.      */
  141.     public static long pastDays(Date date) {
  142.         long t = System.currentTimeMillis() - date.getTime();
  143.         return t / (24 * 60 * 60 * 1000);
  144.     }
  146.     /**
  147.      * 获取过去的小时
  148.      *
  149.      * @param date
  150.      * @return
  151.      */
  152.     public static long pastHour(Date date) {
  153.         long t = System.currentTimeMillis() - date.getTime();
  154.         return t / (60 * 60 * 1000);
  155.     }
  157.     /**
  158.      * 获取过去的分钟
  159.      *
  160.      * @param date
  161.      * @return
  162.      */
  163.     public static long pastMinutes(Date date) {
  164.         long t = System.currentTimeMillis() - date.getTime();
  165.         return t / (60 * 1000);
  166.     }
  168.     /**
  169.      * 转换为时间（天,时:分:秒.毫秒）
  170.      *
  171.      * @param timeMillis
  172.      * @return
  173.      */
  174.     public static String formatDateTime(long timeMillis) {
  175.         long day = timeMillis / (24 * 60 * 60 * 1000);
  176.         long hour = (timeMillis / (60 * 60 * 1000) - day * 24);
  177.         long min = ((timeMillis / (60 * 1000)) - day * 24 * 60 - hour * 60);
  178.         long s = (timeMillis / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
  179.         long sss = (timeMillis - day * 24 * 60 * 60 * 1000 - hour * 60 * 60 * 1000 - min * 60 * 1000 - s * 1000);
  180.         return (day > 0 ? day + "," : "") + hour + ":" + min + ":" + s + "." + sss;
  181.     }
  183.     /**
  184.      * 获取两个日期之间的天数
  185.      *
  186.      * @param before
  187.      * @param after
  188.      * @return
  189.      */
  190.     public static double getDistanceOfTwoDate(Date before, Date after) {
  191.         long beforeTime = before.getTime();
  192.         long afterTime = after.getTime();
  193.         return (afterTime - beforeTime) / (1000 * 60 * 60 * 24);
  194.     }
  196.     /**
  197.      * 获取当前日期前一天日期
  198.      *
  199.      * @return
  200.      */
  201.     public static String getBeforeDate() {
  202.         Calendar calendar = Calendar.getInstance(); //得到日历
  203.         calendar.setTime(new Date());//把当前时间赋给日历
  204.         calendar.add(Calendar.DAY_OF_MONTH, -1);  //设置为前一天
  205.         Date dBefore = calendar.getTime();   //得到前一天的时间
  206.         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd"); //设置时间格式
  207.         String beforeDate = sdf.format(dBefore);    //格式化前一天
  208.         return beforeDate;
  209.     }
  211.     /**
  212.      * @param day     获取当前日期前后day天日期，day>0后几天，day<0前几天
  213.      * @param curdate 当前日期
  214.      * @return
  215.      */
  216.     public static String getAfterDate(int day, String curdate, String dateFormat) {
  217.         Calendar calendar = Calendar.getInstance();
  218.         calendar.setTime(stringToDate(curdate, dateFormat));
  219.         calendar.add(Calendar.DAY_OF_MONTH, day);
  220.         Date dAfter = calendar.getTime();
  221.         SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
  222.         String afterDate = sdf.format(dAfter);
  223.         return afterDate;
  224.     }
  226.     /**
  227.      * @param day 获取当前日期前后day天日期，day>0后几天，day<0前几天
  228.      * @return
  229.      */
  230.     public static String getAfterDate(int day, String dateFormat) {
  231.         Calendar calendar = Calendar.getInstance();
  232.         calendar.setTime(new Date());
  233.         calendar.add(Calendar.DAY_OF_MONTH, day);
  234.         Date dAfter = calendar.getTime();
  235.         SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
  236.         String afterDate = sdf.format(dAfter);
  237.         return afterDate;
  238.     }
  240.     public static Date getThisWeekMonday(Date date) {
  241.         Calendar cal = Calendar.getInstance();
  242.         cal.setTime(date);
  243.         // 获得当前日期是一个星期的第几天
  244.         int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
  245.         if (1 == dayWeek) {
  246.             cal.add(Calendar.DAY_OF_MONTH, -1);
  247.         }
  248.         // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
  249.         cal.setFirstDayOfWeek(Calendar.MONDAY);
  250.         // 获得当前日期是一个星期的第几天
  251.         int day = cal.get(Calendar.DAY_OF_WEEK);
  252.         // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
  253.         cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
  254.         return cal.getTime();
  255.     }
  257.     /**
  258.      * 获取本周一
  259.      *
  260.      * @param dateFormat
  261.      * @return
  262.      */
  263.     public static String getThisWeekMonday(String dateFormat) {
  264.         Calendar cal = Calendar.getInstance();
  265.         cal.setTime(new Date());
  266.         // 获得当前日期是一个星期的第几天
  267.         int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
  268.         if (1 == dayWeek) {
  269.             cal.add(Calendar.DAY_OF_MONTH, -1);
  270.         }
  271.         // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
  272.         cal.setFirstDayOfWeek(Calendar.MONDAY);
  273.         // 获得当前日期是一个星期的第几天
  274.         int day = cal.get(Calendar.DAY_OF_WEEK);
  275.         // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
  276.         cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
  277.         SimpleDateFormat sdf = new SimpleDateFormat(dateFormat); //设置时间格式
  278.         return sdf.format(cal.getTime());
  279.     }
  281.     /**
  282.      * 获取下周一
  283.      *
  284.      * @param dateFormat
  285.      * @return
  286.      */
  287.     public static String getNextWeekMonday(String dateFormat) {
  288.         Calendar cal = Calendar.getInstance();
  289.         cal.setTime(getThisWeekMonday(new Date()));
  290.         cal.add(Calendar.DATE, 7);
  291.         SimpleDateFormat sdf = new SimpleDateFormat(dateFormat); //设置时间格式
  292.         return sdf.format(cal.getTime());
  293.     }
  295.     /**
  296.      * 获取下月
  297.      *
  298.      * @return
  299.      */
  300.     public static String getNextMonth() {
  301.         Calendar c = Calendar.getInstance();
  302.         c.add(Calendar.MONTH, +1);//下个月
  303.         String year = String.valueOf(c.get(Calendar.YEAR));
  304.         //下个月
  305.         String nextMonth = String.valueOf(c.get(Calendar.MONTH) + 1).length() == 2 ? String.valueOf(c.get(Calendar.MONTH) + 1) : "0" + String.valueOf(c.get(Calendar.MONTH) + 1);
  306.         return year + "-" + nextMonth;
  307.     }
  309.     /**
  310.      * 获取本月
  311.      *
  312.      * @return
  313.      */
  314.     public static String getThisMonth() {
  315.         Calendar c = Calendar.getInstance();
  316.         c.add(Calendar.MONTH, 0);//本月
  317.         String year = String.valueOf(c.get(Calendar.YEAR));
  318.         //本月
  319.         String thisMonth = String.valueOf(c.get(Calendar.MONTH) + 1).length() == 2 ? String.valueOf(c.get(Calendar.MONTH) + 1) : "0" + String.valueOf(c.get(Calendar.MONTH) + 1);
  320.         return year + "-" + thisMonth;
  321.     }
  323.     /**
  324.      * 当前季度的开始时间
  325.      *
  326.      * @return
  327.      */
  328.     public static String getCurrentQuarterStartTime(String dateFormat) {
  329.         SimpleDateFormat sdf = new SimpleDateFormat(dateFormat); //设置时间格式
  330.         Calendar c = Calendar.getInstance();
  331.         int currentMonth = c.get(Calendar.MONTH);
  332.         try {
  333.             if (currentMonth >= 1 && currentMonth <= 3) {
  334.                 c.set(Calendar.MONTH, 0);
  335.             } else if (currentMonth >= 4 && currentMonth <= 6) {
  336.                 c.set(Calendar.MONTH, 3);
  337.             } else if (currentMonth >= 7 && currentMonth <= 9) {
  338.                 c.set(Calendar.MONTH, 6);
  339.             } else if (currentMonth >= 10 && currentMonth <= 12) {
  340.                 c.set(Calendar.MONTH, 9);
  341.                 c.set(Calendar.DATE, 1);
  342.             }
  343.         } catch (Exception e) {
  344.             e.printStackTrace();
  345.         }
  346.         return sdf.format(c.getTime());
  347.     }
  349.     /**
  350.      * 当前季度的结束时间
  351.      *
  352.      * @return
  353.      */
  354.     public static String getCurrentQuarterEndDate(String dateFormat) {
  355.         SimpleDateFormat sdf = new SimpleDateFormat(dateFormat); //设置时间格式
  356.         Calendar c = Calendar.getInstance();
  357.         int currentMonth = c.get(Calendar.MONTH) + 1;
  358.         try {
  359.             if (currentMonth >= 1 && currentMonth <= 3) {
  360.                 c.set(Calendar.MONTH, 2);
  361.                 c.set(Calendar.DATE, 31);
  362.             } else if (currentMonth >= 4 && currentMonth <= 6) {
  363.                 c.set(Calendar.MONTH, 5);
  364.                 c.set(Calendar.DATE, 30);
  365.             } else if (currentMonth >= 7 && currentMonth <= 9) {
  366.                 c.set(Calendar.MONTH, 8);
  367.                 c.set(Calendar.DATE, 30);
  368.             } else if (currentMonth >= 10 && currentMonth <= 12) {
  369.                 c.set(Calendar.MONTH, 11);
  370.                 c.set(Calendar.DATE, 31);
  371.             }
  372.         } catch (Exception e) {
  373.             e.printStackTrace();
  374.         }
  375.         c.setTime(new Date());
  376.         return sdf.format(c.getTime());
  377.     }
  379.     /**
  380.      * 当前季度的结束时间
  381.      *
  382.      * @return
  383.      */
  384.     public static String getCurrentQuarterEndDate(String dateFormat, String curMonth) {
  385.         SimpleDateFormat sdf = new SimpleDateFormat(dateFormat); //设置时间格式
  386.         Calendar c = Calendar.getInstance();
  387.         int currentMonth = c.get(Calendar.MONTH) + 1;
  388.         try {
  389.             if (currentMonth >= 1 && currentMonth <= 3) {
  390.                 c.set(Calendar.MONTH, 2);
  391.                 c.set(Calendar.DATE, 31);
  392.             } else if (currentMonth >= 4 && currentMonth <= 6) {
  393.                 c.set(Calendar.MONTH, 5);
  394.                 c.set(Calendar.DATE, 30);
  395.             } else if (currentMonth >= 7 && currentMonth <= 9) {
  396.                 c.set(Calendar.MONTH, 8);
  397.                 c.set(Calendar.DATE, 30);
  398.             } else if (currentMonth >= 10 && currentMonth <= 12) {
  399.                 c.set(Calendar.MONTH, 11);
  400.                 c.set(Calendar.DATE, 31);
  401.             }
  402.         } catch (Exception e) {
  403.             e.printStackTrace();
  404.         }
  405.         c.setTime(stringToDate(curMonth, dateFormat));
  406.         return sdf.format(c.getTime());
  407.     }
  409.     /**
  410.      * 获取月份
  411.      *
  412.      * @param -month     前month月，i后month月
  413.      * @param dateFormat 日期格式
  414.      * @return
  415.      */
  416.     public static String getMonth(int month, String dateFormat) {
  417.         SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
  418.         Calendar c = Calendar.getInstance();
  419.         c.setTime(new Date());
  420.         c.add(Calendar.MONTH, month);
  421.         Date m = c.getTime();
  422.         return sdf.format(m);
  423.     }
  425.     /**
  426.      * 获取月份
  427.      *
  428.      * @param -month     前month月，month后month月
  429.      * @param dateFormat 日期格式 yyyyMM
  430.      * @param curMonth
  431.      * @return
  432.      */
  433.     public static String getMonth(int month, String curMonth, String dateFormat) {
  434.         SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
  435.         Calendar c = Calendar.getInstance();
  436.         c.setTime(stringToDate(curMonth, dateFormat));
  437.         c.add(Calendar.MONTH, month);
  438.         Date m = c.getTime();
  439.         return sdf.format(m);
  440.     }
  442.     /**
  443.      * 获取前minute分钟时间:如-4，后minute分钟时间:如 4
  444.      *
  445.      * @param minute 格式 yyyy-MM-dd HH:mm:ss
  446.      * @return
  447.      */
  448.     public static String getBeforeMinute(int minute) {
  449.         SimpleDateFormat sdf = new SimpleDateFormat(parsePatterns[1]);
  450.         Calendar beforeTime = Calendar.getInstance();
  451.         beforeTime.add(Calendar.MINUTE, minute);
  452.         Date beforeD = beforeTime.getTime();
  453.         String time = sdf.format(beforeD);
  454.         return time;
  455.     }
  457.     public static Date getIntervalMinute(int minute) {
  458.         SimpleDateFormat sdf = new SimpleDateFormat(parsePatterns[1]);
  459.         Calendar beforeTime = Calendar.getInstance();
  460.         beforeTime.add(Calendar.MINUTE, minute);
  461.         Date beforeD = beforeTime.getTime();
  462.         return beforeD;
  463.     }
  465.     /**
  466.      * 获取前minute分钟:如-4，后minute分钟:如 4
  467.      * @param minute
  468.      * @return
  469.      */
  470.     public static int getMinute(int minute){
  471.         String dataTime = getBeforeMinute(minute);
  472.         String[] time = dataTime.split(" ")[1].split(":");
  473.         //时间转为分钟数
  474.         int mi = Integer.valueOf(time[0])*60 + Integer.valueOf(time[1]);
  475.         return mi;
  476.     }
  478.     /**
  479.      * 获取前minute分钟时间:如-4，后minute分钟时间:如 4
  480.      *
  481.      * @param curDateTime 当前时间
  482.      * @param minute      间隔分钟
  483.      *                    格式 yyyy-MM-dd HH:mm:ss
  484.      * @return
  485.      */
  486.     public static String getBeforeMinute(String curDateTime, int minute) {
  487.         SimpleDateFormat sdf = new SimpleDateFormat(parsePatterns[1]);
  488.         Calendar beforeTime = Calendar.getInstance();
  489.         beforeTime.setTime(stringToDate(curDateTime, null));
  490.         beforeTime.add(Calendar.MINUTE, minute);
  491.         Date beforeD = beforeTime.getTime();
  492.         String time = sdf.format(beforeD);
  493.         return time;
  494.     }
  496.     /**
  497.      * 获取前hour小时:如-4，后hour小时:如 4
  498.      *
  499.      * @param hour 格式 yyyy-MM-dd HH:mm:ss
  500.      * @return
  501.      */
  502.     public static String getBeforeHour(int hour) {
  503.         SimpleDateFormat sdf = new SimpleDateFormat(parsePatterns[1]);
  504.         Calendar beforeTime = Calendar.getInstance();
  505.         beforeTime.add(Calendar.HOUR_OF_DAY, hour);
  506.         Date beforeD = beforeTime.getTime();
  507.         String time = sdf.format(beforeD);
  508.         return time;
  509.     }
  511.     /**
  512.      * 获取前second秒:如-4，后second秒:如 4
  513.      *
  514.      * @param second 格式 yyyy-MM-dd HH:mm:ss
  515.      * @return
  516.      */
  517.     public static String getBeforeSecond(int second) {
  518.         SimpleDateFormat sdf = new SimpleDateFormat(parsePatterns[1]);
  519.         Calendar beforeTime = Calendar.getInstance();
  520.         beforeTime.add(Calendar.SECOND, second);
  521.         Date beforeD = beforeTime.getTime();
  522.         String time = sdf.format(beforeD);
  523.         return time;
  524.     }
  526.     /**
  527.      * @param date1   字符串日期1
  528.      * @param date2   字符串日期2
  529.      * @param pattern 日期格式化方式
  530.      * @return
  531.      * @descript:计算两个字符串月相差的月数
  532.      */
  533.     public static int countMonths(String date1, String date2, String pattern) {
  534.         SimpleDateFormat sdf = new SimpleDateFormat(pattern);
  535.         Calendar c1 = Calendar.getInstance();
  536.         Calendar c2 = Calendar.getInstance();
  537.         try {
  538.             c1.setTime(sdf.parse(date1));
  539.             c2.setTime(sdf.parse(date2));
  540.         } catch (ParseException e) {
  541.             e.printStackTrace();
  542.         }
  543.         int year = c2.get(Calendar.YEAR) - c1.get(Calendar.YEAR);
  544.         //开始日期若小月结束日期
  545.         if (year < 0) {
  546.             year = -year;
  547.             return year * 12 + c1.get(Calendar.MONTH) - c2.get(Calendar.MONTH);
  548.         }
  549.         return year * 12 + c2.get(Calendar.MONTH) - c1.get(Calendar.MONTH);
  550.     }
  552.     /**
  553.      * 获取当前时间前几天，当前天，后几天日期yyyyMMdd
  554.      *
  555.      * @param day        和当期天的间隔天数 day前几天，-day：前day天，day：后day天
  556.      * @param dateFormat 时间格式
  557.      * @return
  558.      */
  559.     public static String getDay(int day, String dateFormat) {
  560.         Calendar calendar = Calendar.getInstance();
  561.         calendar.add(Calendar.DATE, day);
  562.         Date date = calendar.getTime();
  563.         SimpleDateFormat df = new SimpleDateFormat(dateFormat);
  564.         return df.format(date);
  565.     }
  567.     /**
  568.      * 获取当前时间前几天，当前天，后几天日期yyyyMMdd
  569.      *
  570.      * @param day        和当期天的间隔天数 day前几天，-day：前day天，day：后day天
  571.      * @param dateFormat 时间格式
  572.      * @return
  573.      */
  574.     public static String getDay(int day, String dateFormat, String curDay) {
  575.         Calendar c = Calendar.getInstance();
  576.         c.setTime(stringToDate(curDay, dateFormat));
  577.         c.add(Calendar.DATE, day);
  578.         Date date = c.getTime();
  579.         SimpleDateFormat df = new SimpleDateFormat(dateFormat);
  580.         return df.format(date);
  581.     }
  583.     /**
  584.      * 获取当前时间小时
  585.      *
  586.      */
  587.     public static String getHour() {
  588.         GregorianCalendar calendar = new GregorianCalendar();
  589.         int hour = calendar.get(Calendar.HOUR_OF_DAY);
  590.         return hour + "";
  591.     }
  593.     /**
  594.      * 星期表达式转换
  595.      *
  596.      * @param weekType
  597.      * @return
  598.      */
  599.     public static int getNumWeek(String weekType) {
  600.         int week = 0;
  601.         switch (weekType) {
  602.             case "星期一":
  603.                 week = 1;
  604.                 break;
  605.             case "星期二":
  606.                 week = 2;
  607.                 break;
  608.             case "星期三":
  609.                 week = 3;
  610.                 break;
  611.             case "星期四":
  612.                 week = 4;
  613.                 break;
  614.             case "星期五":
  615.                 week = 5;
  616.                 break;
  617.             case "星期六":
  618.                 week = 6;
  619.                 break;
  620.             case "星期日":
  621.                 week = 7;
  622.                 break;
  623.             default:
  624.         }
  625.         return week;
  626.     }
  628.     /**
  629.      * 星期表达式转换
  630.      *
  631.      * @param weekNum
  632.      * @return
  633.      */
  634.     public static String getWeekByNum(Integer weekNum) {
  635.         String week = "";
  636.         switch (weekNum) {
  637.             case 1:
  638.                 week = "星期一";
  639.                 break;
  640.             case 2:
  641.                 week = "星期二";
  642.                 break;
  643.             case 3:
  644.                 week = "星期三";
  645.                 break;
  646.             case 4:
  647.                 week = "星期四";
  648.                 break;
  649.             case 5:
  650.                 week = "星期五";
  651.                 break;
  652.             case 6:
  653.                 week = "星期六";
  654.                 break;
  655.             case 7:
  656.                 week = "星期日";
  657.                 break;
  658.             default:
  659.         }
  660.         return week;
  661.     }
  663.     /**
  664.      * @param week       星期类型 :例如：星期一、星期二、星期三、星期四、星期五、星期六、星期日
  665.      * @param dateFormat 返回的日期格式
  666.      * @return
  667.      */
  668.     public static String getDayByWeek(String week, String dateFormat) {
  669.         int numWeek1 = getNumWeek(getWeek());
  670.         int numWeek2 = getNumWeek(week);
  671.         int weekdiff = numWeek2 - numWeek1;
  672.         return getDay(weekdiff, dateFormat);
  673.     }
  675.     /**
  676.      * @param week       星期类型 :例如：星期一、星期二、星期三、星期四、星期五、星期六、星期日
  677.      * @param dateFormat 返回的日期格式
  678.      * @return
  679.      */
  680.     public static String getDayByWeek(String week, String dateFormat, String curDay) {
  681.         int numWeek1 = getNumWeek(getWeek(curDay));
  682.         int numWeek2 = getNumWeek(week);
  683.         int weekdiff = numWeek2 - numWeek1;
  684.         return getDay(weekdiff, dateFormat, curDay);
  685.     }
  687.     /**
  688.      * 当前日期所在周的前一周
  689.      * 例如：201907
  690.      *
  691.      * @return
  692.      * @throws ParseException
  693.      */
  694.     public static String getWeekAndYear(int day) {
  695.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
  696.         Date date = null;
  697.         try {
  698.             date = format.parse(getAfterDate(day, "yyyy-MM-dd"));
  699.         } catch (ParseException e) {
  700.             e.getMessage();
  701.         }
  702.         Calendar cal = Calendar.getInstance();
  703.         //设置周一为一周的第一天
  704.         cal.setFirstDayOfWeek(Calendar.MONDAY);
  705.         cal.setTime(date);
  706.         int week = cal.get(Calendar.WEEK_OF_YEAR);
  707.         int year = cal.get(Calendar.YEAR);
  708.         int month = cal.get(Calendar.MONTH);
  709.         //如果月份是12月，且求出来的周数是第一周，说明该日期实质上是这一年的第53周，也是下一年的第一周
  710.         if(month>=11 && week <= 1){
  711.             week +=52;
  712.         }
  713.         String yearWeek = "";
  714.         if (week < 10) {
  715.             yearWeek = year + "0" + week;
  716.         } else {
  717.             yearWeek = year + "" + week;
  718.         }
  719.         return yearWeek;
  720.     }
  722.     /**
  723.      * 当前日期所在周的前一周
  724.      * 例如：201907
  725.      *
  726.      * @return
  727.      * @throws ParseException
  728.      */
  729.     public static String getWeekAndYear(int day, String curWeek) {
  730.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
  731.         Date date = null;
  732.         try {
  733.             date = format.parse(getAfterDate(day, "yyyy-MM-dd"));
  734.         } catch (ParseException e) {
  735.             e.getMessage();
  736.         }
  737.         Calendar cal = Calendar.getInstance();
  738.         //设置周一为一周的第一天
  739.         cal.setFirstDayOfWeek(Calendar.MONDAY);
  740.         cal.setTime(date);
  741.         int week = cal.get(Calendar.WEEK_OF_YEAR);
  742.         int year = cal.get(Calendar.YEAR);
  743.         int month = cal.get(Calendar.MONTH);
  744.         //如果月份是12月，且求出来的周数是第一周，说明该日期实质上是这一年的第53周，也是下一年的第一周
  745.         if(month>=11 && week <= 1){
  746.             week +=52;
  747.         }
  748.         String yearWeek = "";
  749.         if (week < 10) {
  750.             yearWeek = year + "0" + week;
  751.         } else {
  752.             yearWeek = year + "" + week;
  753.         }
  754.         return yearWeek;
  755.     }
  757.     /**
  758.      * 通过日期获取周数
  759.      * 格式：yyyy-MM-dd
  760.      * @param day
  761.      * @return
  762.      */
  763.     public static String getWeekAndYear(String day, String pattern) {
  764.         SimpleDateFormat format = new SimpleDateFormat(pattern);
  765.         Date date = null;
  766.         try {
  767.             date = format.parse(day);
  768.         } catch (ParseException e) {
  769.             e.getMessage();
  770.         }
  771.         Calendar cal = Calendar.getInstance();
  772.         //设置周一为一周的第一天
  773.         cal.setFirstDayOfWeek(Calendar.MONDAY);
  774.         cal.setTime(date);
  775.         int week = cal.get(Calendar.WEEK_OF_YEAR);
  776.         int year = cal.get(Calendar.YEAR);
  777.         int month = cal.get(Calendar.MONTH);
  778.         //如果月份是12月，且求出来的周数是第一周，说明该日期实质上是这一年的第53周，也是下一年的第一周
  779.         if(month>=11 && week <= 1){
  780.             week +=52;
  781.         }
  782.         String yearWeek = "";
  783.         if (week < 10) {
  784.             yearWeek = year + "0" + week;
  785.         } else {
  786.             yearWeek = year + "" + week;
  787.         }
  788.         return yearWeek;
  789.     }
  791.     /**
  792.      * 获取日期所在周
  793.      *
  794.      * @param curDate 格式：yyyyMMdd
  795.      * @return
  796.      */
  797.     public static String getWeekByDate(String curDate) {
  798.         SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
  799.         Date date = null;
  800.         try {
  801.             date = format.parse(curDate);
  802.         } catch (ParseException e) {
  803.             e.printStackTrace();
  804.         }
  805.         Calendar calendar = Calendar.getInstance();
  806.         calendar.setFirstDayOfWeek(Calendar.MONDAY);
  807.         calendar.setTime(date);
  808.         int week = calendar.get(Calendar.WEEK_OF_YEAR);
  809.         int year = calendar.getWeekYear();
  810.         String yearWeek = "";
  811.         if(week <10){
  812.             yearWeek = year + "0"+ week;
  813.         }else{
  814.             yearWeek = year + ""+ week;
  815.         }
  816.         return yearWeek;
  817.     }
  819.     /**
  820.      * 增加半小时
  821.      * @param day
  822.      * @param min
  823.      * @return
  824.      */
  825.     public static String addHalfHour(String day, int min){
  826.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  827.         Date date = null;
  828.         try {
  829.             date = format.parse(day);
  830.         } catch (Exception ex) {
  831.             ex.printStackTrace();
  832.         }
  833.         if (date == null) {
  834.             return "";
  835.         }
  836.         Calendar cal = Calendar.getInstance();
  837.         cal.setTime(date);
  838.         // 24小时制
  839.         cal.add(Calendar.MINUTE, min);
  840.         date = cal.getTime();
  841.         return format.format(date);
  842.     }
  844.     /**
  845.      * 窗口时间换算成毫秒数
  846.      * @param windowTime
  847.      * @return
  848.      */
  849.     public static Long getWindowMillis(String windowTime){
  850.         long windowTimeSecond = -1;
  851.         String hour = "小时";
  852.         String minute = "分钟";
  853.         String second = "秒";
  854.         if (windowTime == null || windowTime.trim().length() == 0) {
  855.             return windowTimeSecond;
  856.         }
  857.         windowTime = windowTime.replaceAll(" ", "");
  858.         if (windowTime.indexOf(second) > 0) {
  859.             windowTime = windowTime.replace(second, "").trim();
  860.             windowTimeSecond = Integer.parseInt(windowTime) * 1000;
  861.         } else if (windowTime.indexOf(minute) > 0) {
  862.             windowTime = windowTime.replace(minute, "").trim();
  863.             windowTimeSecond = Integer.parseInt(windowTime) * 60 * 1000;
  864.         } else if (windowTime.indexOf(hour) > 0) {
  865.             windowTime = windowTime.replace(hour, "").trim();
  866.             windowTimeSecond = Integer.parseInt(windowTime) * 60 * 60 * 1000;
  867.         }
  868.         return windowTimeSecond;
  869.     }
  871.     /**
  872.      * 获取所在周开始时间
  873.      * @param weekYear 年 2020
  874.      * @param weekOfYear 周 12
  875.      * @param pattern 日期格式
  876.      * @return
  877.      */
  878.     public static String getFirstDayOfWeek(int weekYear, int weekOfYear, String pattern){
  879.         Calendar calendar = Calendar.getInstance();
  880.         //设置星期一为一周开始的第一天
  881.         calendar.setFirstDayOfWeek(Calendar.MONDAY);
  882.         //可以不用设置
  883.         calendar.setMinimalDaysInFirstWeek(4);
  884.         calendar.setTimeInMillis(System.currentTimeMillis());
  885.         //获得指定年的第几周的开始日期
  886.         calendar.setWeekDate(weekYear, weekOfYear, 2);
  887.         //创建日期的时间该周的第一天
  888.         long starttime = calendar.getTime().getTime();
  889.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
  890.         //将时间戳格式化为指定格式
  891.         String dateStart = simpleDateFormat.format(starttime);
  892.         dateStart = getAfterDate(-7, dateStart, pattern);
  893.         return dateStart;
  894.     }
  896.     /**
  897.      * 获取指定周前几周
  898.      * @param curWeek 当前周 202012
  899.      * @param num 前后几周
  900.      * @param pattern 日期格式
  901.      * @return
  902.      */
  903.     public static String getAfterWeek(String curWeek,int num, String pattern){
  904.         //年
  905.         int weekYear = Integer.valueOf(curWeek.substring(0,4));
  906.         //周数
  907.         int weekOfYear = Integer.valueOf(curWeek.substring(4,6));
  908.         //周对应的开始日期
  909.         String weekDate = getFirstDayOfWeek(weekYear, weekOfYear, pattern);
  910.         //获取前后几天
  911.         String afterDate = getAfterDate(num*7, weekDate, pattern);
  912.         String yearAndWeek = getWeekAndYear(afterDate,pattern);
  913.         //年
  914.         int weekYear1 = Integer.valueOf(yearAndWeek.substring(0,4));
  915.         //当前年和前一年同时存在，取当前年第一周
  916.         if(weekYear > weekYear1){
  917.             yearAndWeek = weekYear+"01";
  918.         }
  919.         return yearAndWeek;
  920.     }
  922.     /**
  923.      * 计算相差的天数
  924.      * @param startDate
  925.      * @param endDate
  926.      * @return
  927.      * @throws ParseException
  928.      */
  929.     public static int getDayDiffer(Date startDate, Date endDate) {
  930.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
  931.         long startDateTime = 0;
  932.         try {
  933.             startDateTime = dateFormat.parse(dateFormat.format(startDate)).getTime();
  934.             long endDateTime = dateFormat.parse(dateFormat.format(endDate)).getTime();
  935.             return (int) ((endDateTime - startDateTime) / (1000 * 3600 * 24));
  936.         } catch (ParseException e) {
  937.             e.printStackTrace();
  938.         }
  940.         return 0;
  941.     }
  943.     public static int getMiniteDiffer(Date startDate, Date endDate) {
  944.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  945.         long startDateTime = 0;
  946.         try {
  947.             startDateTime = dateFormat.parse(dateFormat.format(startDate)).getTime();
  948.             long endDateTime = dateFormat.parse(dateFormat.format(endDate)).getTime();
  949.             return (int) (endDateTime - startDateTime) / (1000 * 60);
  950.         } catch (ParseException e) {
  951.             e.printStackTrace();
  952.         }
  953.         return 0;
  954.     }
  956.     /**
  957.      * 获取指定时间diff小时后的数据
  958.      * @param strDate
  959.      * @param pattern
  960.      * @param diff
  961.      * @return
  962.      */
  963.     public static String getHourDiffer(String strDate, String pattern, int diff) {
  964.         Date date = DateUtils.stringToDate(strDate, pattern);
  965.         Calendar rightNow = Calendar.getInstance();
  966.         rightNow.setTime(date);
  967.         rightNow.add(Calendar.HOUR, diff);
  968.         rightNow.add(Calendar.MINUTE, -5);
  969.         Date time = rightNow.getTime();
  970.         String times = DateUtils.formatDateTime(time);
  971.         return times;
  972.     }
  973. }