springboot DateUtil获取本周，本年，本月开始结束时间

约定不等于承诺〃 2023-10-04 22:27 122阅读 0赞 
  1. package com.bandweaver.tunnel.common.platform.util;
  5. import java.sql.Timestamp;
  6. import java.text.DateFormat;
  7. import java.text.ParsePosition;
  8. import java.text.SimpleDateFormat;
  9. import java.util.ArrayList;
  10. import java.util.Calendar;
  11. import java.util.Date;
  12. import java.util.GregorianCalendar;
  13. import java.util.HashMap;
  14. import java.util.List;
  15. import java.util.Map;
  17. import com.bandweaver.tunnel.common.biz.constant.TimeEnum;
  19. public class DateUtil {
  22.     public static Date getCurrentDate() {
  23.         return new Date();
  24.     }
  27.     /**
  28.      * 获取当天的开始时间
  29.      */
  30.     public static Date getDayBegin() {
  31.         Calendar cal = new GregorianCalendar();
  32.         cal.set(Calendar.HOUR_OF_DAY, 0);
  33.         cal.set(Calendar.MINUTE, 0);
  34.         cal.set(Calendar.SECOND, 0);
  35.         cal.set(Calendar.MILLISECOND, 0);
  36.         return cal.getTime();
  37.     }
  39.     /**
  40.      * 获取当天的结束时间
  41.      * @return
  42.      */
  43.     public static Date getDayEnd() {
  44.         Calendar cal = new GregorianCalendar();
  45.         cal.set(Calendar.HOUR_OF_DAY, 23);
  46.         cal.set(Calendar.MINUTE, 59);
  47.         cal.set(Calendar.SECOND, 59);
  48.         return cal.getTime();
  49.     }
  51.     /**
  52.      * 获取昨天的开始时间
  53.      * @return
  54.      */
  55.     public static Date getBeginDayOfYesterday() {
  56.         Calendar cal = new GregorianCalendar();
  57.         cal.setTime(getDayBegin());
  58.         cal.add(Calendar.DAY_OF_MONTH, -1);
  59.         return cal.getTime();
  60.     }
  62.     /**
  63.      * 获取昨天的结束时间
  64.      * @return
  65.      */
  66.     public static Date getEndDayOfYesterDay() {
  67.         Calendar cal = new GregorianCalendar();
  68.         cal.setTime(getDayEnd());
  69.         cal.add(Calendar.DAY_OF_MONTH, -1);
  70.         return cal.getTime();
  71.     }
  73.     /**
  74.      * 获取明天的开始时间
  75.      * @return
  76.      */
  77.     public static Date getBeginDayOfTomorrow() {
  78.         Calendar cal = new GregorianCalendar();
  79.         cal.setTime(getDayBegin());
  80.         cal.add(Calendar.DAY_OF_MONTH, 1);
  82.         return cal.getTime();
  83.     }
  84.     //获取明天的结束时间
  85.     public static Date getEndDayOfTomorrow() {
  86.         Calendar cal = new GregorianCalendar();
  87.         cal.setTime(getDayEnd());
  88.         cal.add(Calendar.DAY_OF_MONTH, 1);
  89.         return cal.getTime();
  90.     }
  92.     /**
  93.      * 获取本周的开始时间
  94.      * @return
  95.      */
  96.     public static Date getBeginDayOfWeek() {
  97.         Date date = new Date();
  98.         return getBeginDayOfWeek(date);
  99.     }
  100.     /**
  101.      * 获取本周的开始时间
  102.      * @return
  103.      */
  104.     public static Date getBeginDayOfWeek(Date date) {
  105.         if (date == null) {
  106.             return null;
  107.         }
  108.         Calendar cal = Calendar.getInstance();
  109.         cal.setTime(date);
  110.         int dayofweek = cal.get(Calendar.DAY_OF_WEEK);
  111.         if (dayofweek == 1) {
  112.             dayofweek += 7;
  113.         }
  114.         cal.add(Calendar.DATE, 2 - dayofweek);
  115.         return getDayStartTime(cal.getTime());
  116.     }
  118.     /**
  119.      * 获取本周的结束时间
  120.      * @return
  121.      */
  122.     public static Date getEndDayOfWeek(){
  123.         Calendar cal = Calendar.getInstance();
  124.         cal.setTime(getBeginDayOfWeek());
  125.         cal.add(Calendar.DAY_OF_WEEK, 6);
  126.         Date weekEndSta = cal.getTime();
  127.         return getDayEndTime(weekEndSta);
  128.     }
  130.     /**获取本周的结束时间 
  131.      * @param date
  132.      * @return   
  133.      * @author shaosen
  134.      * @Date 2018年9月12日
  135.      */
  136.     public static Date getEndDayOfWeek(Date date){
  137.         Calendar cal = Calendar.getInstance();
  138.         cal.setTime(getBeginDayOfWeek(date));
  139.         cal.add(Calendar.DAY_OF_WEEK, 6);
  140.         Date weekEndSta = cal.getTime();
  141.         return getDayEndTime(weekEndSta);
  142.     }
  144.     /**
  145.      * 获取本月的开始时间
  146.      * @return
  147.      */
  148.     public static Date getBeginDayOfMonth() {
  149.         Calendar calendar = Calendar.getInstance();
  150.         calendar.set(getNowYear(), getNowMonth() - 1, 1);
  151.         return getDayStartTime(calendar.getTime());
  152.     }
  153.     /**
  154.      * 获取本月的开始时间
  155.      * @return
  156.      */
  157.     public static Date getBeginDayOfMonth(Date time){
  158.         Calendar calendar = Calendar.getInstance();
  159.         calendar.setTime(time);
  160.         calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH) , 1);
  161.         return getDayStartTime(calendar.getTime());
  162.     }
  164.     /**
  165.      * 获取本月的结束时间
  166.      * @return
  167.      */
  168.     public static Date getEndDayOfMonth() {
  169.         Calendar calendar = Calendar.getInstance();
  170.         calendar.set(getNowYear(), getNowMonth() - 1, 1);
  171.         int day = calendar.getActualMaximum(5);
  172.         calendar.set(getNowYear(), getNowMonth() - 1, day);
  173.         return getDayEndTime(calendar.getTime());
  174.     }
  177.     /**
  178.      * 获取本月的结束时间
  179.      * @return
  180.      */
  181.     public static Date getEndDayOfMonth(Date time) {
  182.         Calendar calendar = Calendar.getInstance();
  183.         calendar.setTime(time);
  184.         calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH) , 1);
  185.         int day = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
  186.         calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH) , day);
  187.         return getDayEndTime(calendar.getTime());
  188.     }
  190.     /**
  191.      * 获取本年的开始时间
  192.      * @return
  193.      */
  194.     public static Date getBeginDayOfYear() {
  195.         return getBeginDayOfYear(new Date());
  196.     }
  198.     /**
  199.      * 获得time所在年的第一天
  200.      * @param time
  201.      * @return
  202.      */
  203.     public static Date getBeginDayOfYear(Date time){
  204.         Calendar cal = Calendar.getInstance();
  205.         cal.setTime(time);
  206.         cal.set(Calendar.YEAR, cal.get(Calendar.YEAR));
  207.         cal.set(Calendar.MONTH, Calendar.JANUARY);
  208.         cal.set(Calendar.DATE, 1);
  210.         return getDayStartTime(cal.getTime());
  211.     }
  213.     /**
  214.      * 获取本年的结束时间
  215.      * @return
  216.      */
  217.     public static Date getEndDayOfYear() {
  218.         return getEndDayOfYear(new Date());
  219.     }
  222.     /**
  223.      * 获取本年的结束时间
  224.      * @return
  225.      */
  226.     public static Date getEndDayOfYear(Date time) {
  227.         Calendar cal = Calendar.getInstance();
  228.         cal.setTime(time);
  229.         cal.set(Calendar.YEAR, cal.get(Calendar.YEAR));
  230.         cal.set(Calendar.MONTH, Calendar.DECEMBER);
  231.         cal.set(Calendar.DATE, 31);
  232.         return getDayEndTime(cal.getTime());
  233.     }
  235.     /**
  236.      * 获取某个日期的开始时间
  237.      * @param d
  238.      * @return
  239.      */
  240.     public static Date getDayStartTime(Date d) {
  241.         Calendar calendar = Calendar.getInstance();
  242.         if(null != d) calendar.setTime(d);
  243.         calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH),calendar.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
  244.         calendar.set(Calendar.MILLISECOND, 0);
  245. //        return new Timestamp(calendar.getTimeInMillis());
  246.         return calendar.getTime();
  247.     }
  249.     /**
  250.      * 获取某个日期的结束时间
  251.      * @param d
  252.      * @return
  253.      */
  254.     public static Date getDayEndTime(Date d) {
  255.         Calendar calendar = Calendar.getInstance();
  256.         if(null != d) calendar.setTime(d);
  257.         calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 23, 59, 59);
  258.         calendar.set(Calendar.MILLISECOND, 999);
  259. //        return new Timestamp(calendar.getTimeInMillis());
  260.        return calendar.getTime();
  261.     }
  263.     /**
  264.      * 获取今年是哪一年
  265.      * @return
  266.      */
  267.     public static Integer getNowYear() {
  268.         Date date = new Date();
  269.         return getNowYear(date);
  270.     }
  271.     /**
  272.      * 获取今年是哪一年
  273.      * @return
  274.      */
  275.     public static Integer getNowYear(Date date) {
  276.         GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
  277.         gc.setTime(date);
  278.         return Integer.valueOf(gc.get(1));
  279.     }
  281.     /**
  282.      * 获取本月是哪一月
  283.      * @return
  284.      */
  285.     public static int getNowMonth() {
  286.         Date date = new Date();
  287.         return getNowMonth(date);
  288.     }
  289.     /**
  290.      * 获取本月是哪一月
  291.      * @return
  292.      */
  293.     public static int getNowMonth(Date date) {
  294.         GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
  295.         gc.setTime(date);
  296.         return gc.get(2) + 1;
  297.     }
  299.     /**
  300.      * @Description: 获取当日是第几周
  301.      * @param @param date
  302.      * @param @return   
  303.      * @return int  
  304.      * @throws
  305.      * @author shaosen
  306.      * @date 2018年6月1日
  307.      */
  308.     public static int getNowWeek(Date date) {
  309.         Calendar ca = Calendar.getInstance();
  310.         ca.setTime(date);
  311.         return ca.get(Calendar.WEEK_OF_YEAR);
  312.     }
  314.     /**
  315.      * 两个日期相减得到的天数
  316.      * @param beginDate
  317.      * @param endDate
  318.      * @return
  319.      */
  320.     public static int getDiffDays(Date beginDate, Date endDate) {
  322.         if (beginDate == null || endDate == null) {
  323.             throw new IllegalArgumentException("getDiffDays param is null!");
  324.         }
  326.         long diff = (endDate.getTime() - beginDate.getTime())
  327.                 / (1000 * 60 * 60 * 24);
  329.         int days = new Long(diff).intValue();
  331.         return days;
  332.     }
  334.     /**
  335.      * @Description: 获取两个日期的时间差
  336.      * @param @param beginDate
  337.      * @param @param endDate   
  338.      * @return long  
  339.      * @throws
  340.      * @author shaosen
  341.      * @date 2018年6月13日
  342.      */
  343.     public static long getDiffHours(Date beginDate, Date endDate) {
  344.         long between = dateDiff(beginDate, endDate);
  345.         long day = between / (24 * 60 * 60 * 1000);
  346.         long hours = (between / (60 * 60 * 1000) - day * 24);
  347.         return day*24+hours;
  348.     }
  350.     /**
  351.      * 两个日期相减得到的毫秒数
  352.      * @param beginDate
  353.      * @param endDate
  354.      * @return
  355.      */
  356.     public static long dateDiff(Date beginDate, Date endDate) {
  357.         long date1ms = beginDate.getTime();
  358.         long date2ms = endDate.getTime();
  359.         return date2ms - date1ms;
  360.     }
  362.     /**
  363.      * 获取两个日期中的最大日期
  364.      * @param beginDate
  365.      * @param endDate
  366.      * @return
  367.      */
  368.     public static Date max(Date beginDate, Date endDate) {
  369.         if (beginDate == null) {
  370.             return endDate;
  371.         }
  372.         if (endDate == null) {
  373.             return beginDate;
  374.         }
  375.         if (beginDate.after(endDate)) {
  376.             return beginDate;
  377.         }
  378.         return endDate;
  379.     }
  381.     /**
  382.      * 获取两个日期中的最小日期
  383.      * @param beginDate
  384.      * @param endDate
  385.      * @return
  386.      */
  387.     public static Date min(Date beginDate, Date endDate) {
  388.         if (beginDate == null) {
  389.             return endDate;
  390.         }
  391.         if (endDate == null) {
  392.             return beginDate;
  393.         }
  394.         if (beginDate.after(endDate)) {
  395.             return endDate;
  396.         }
  397.         return beginDate;
  398.     }
  400.     /**
  401.      * 返回某月该季度的第一个月
  402.      * @param date
  403.      * @return
  404.      */
  405.     public static Date getFirstSeasonDate(Date date) {
  406.         final int[] SEASON = { 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4 };
  407.         Calendar cal = Calendar.getInstance();
  408.         cal.setTime(date);
  409.         int sean = SEASON[cal.get(Calendar.MONTH)];
  410.         cal.set(Calendar.MONTH, sean * 3 - 3);
  411.         return cal.getTime();
  412.     }
  414.     /**
  415.      * 返回某个日期下几天的日期
  416.      * @param date
  417.      * @param i
  418.      * @return
  419.      */
  420.     public static Date getNextDay(Date date, int i) {
  421.         Calendar cal = new GregorianCalendar();
  422.         cal.setTime(date);
  423.         cal.set(Calendar.DATE, cal.get(Calendar.DATE) + i);
  424.         return cal.getTime();
  425.     }
  427.     /**
  428.      * 返回某个日期前几天的日期
  429.      * @param date
  430.      * @param i
  431.      * @return
  432.      */
  433.     public static Date getFrontDay(Date date, int i) {
  434.         Calendar cal = new GregorianCalendar();
  435.         cal.setTime(date);
  436.         cal.set(Calendar.DATE, cal.get(Calendar.DATE) - i);
  437.         return cal.getTime();
  438.     }
  440.     /**
  441.      * 获取某年某月到某年某月按天的切片日期集合（间隔天数的日期集合）
  442.      * @param beginYear
  443.      * @param beginMonth
  444.      * @param endYear
  445.      * @param endMonth
  446.      * @param k
  447.      * @return
  448.      */
  449.     public static List getTimeList(int beginYear, int beginMonth, int endYear,
  450.                                    int endMonth, int k) {
  451.         List list = new ArrayList();
  452.         if (beginYear == endYear) {
  453.             for (int j = beginMonth; j <= endMonth; j++) {
  454.                 list.add(getTimeList(beginYear, j, k));
  456.             }
  457.         } else {
  458.             {
  459.                 for (int j = beginMonth; j < 12; j++) {
  460.                     list.add(getTimeList(beginYear, j, k));
  461.                 }
  463.                 for (int i = beginYear + 1; i < endYear; i++) {
  464.                     for (int j = 0; j < 12; j++) {
  465.                         list.add(getTimeList(i, j, k));
  466.                     }
  467.                 }
  468.                 for (int j = 0; j <= endMonth; j++) {
  469.                     list.add(getTimeList(endYear, j, k));
  470.                 }
  471.             }
  472.         }
  473.         return list;
  474.     }
  476.     /**
  477.      * 获取某年某月按天切片日期集合（某个月间隔多少天的日期集合）
  478.      * @param beginYear
  479.      * @param beginMonth
  480.      * @param k
  481.      * @return
  482.      */
  483.     public static List getTimeList(int beginYear, int beginMonth, int k) {
  484.         List list = new ArrayList();
  485.         Calendar begincal = new GregorianCalendar(beginYear, beginMonth, 1);
  486.         int max = begincal.getActualMaximum(Calendar.DATE);
  487.         for (int i = 1; i < max; i = i + k) {
  488.             list.add(begincal.getTime());
  489.             begincal.add(Calendar.DATE, k);
  490.         }
  491.         begincal = new GregorianCalendar(beginYear, beginMonth, max);
  492.         list.add(begincal.getTime());
  493.         return list;
  494.     }
  496.     /**
  497.      * 将精确到s的时间戳转化为时间
  498.      * @param t
  499.      * @return
  500.      */
  501.     public static Date setTimestamp2Date(long t){
  502.         return new Date(t * 1000);
  503.     }
  505.     /**
  506.      * 将精确到毫秒的时间戳转化为时间
  507.      * @param t
  508.      * @return
  509.      */
  510.     public static Date setMillisTimestamp2Date(long t){
  511.         return new Date(t);
  512.     }
  514.     /**
  515.      * 将时间转化为s的时间戳
  516.      * @param d
  517.      * @return
  518.      */
  519.     public static Long setDate2Timestamp(Date d){
  520.         return d.getTime() / 1000;
  521.     }
  523.     /**
  524.      * 将时间转化为毫秒为单位的时间戳
  525.      * @param d
  526.      * @return
  527.      */
  528.     public static Long setDate2MillisTimestamp(Date d){
  529.         return d.getTime();
  530.     }
  532.     /**
  533.      * string格式转Date yyyy-MM-dd HH:mm:ss
  534.      * @param s
  535.      * @return
  536.      */
  537.     public static Date getString2Date(String s){
  538.         if(s==null||s.trim().length()<0) {
  539.             return null;
  540.         }
  541.         DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  542.         ParsePosition pos = new ParsePosition(0);
  543.         return formatter.parse(s, pos);
  544.     }
  547.     /**
  548.      * 将时间转化为string格式 yyyy-MM-dd HH:mm:ss
  549.      * @param d
  550.      * @return
  551.      */
  552.     public static String getDate2String(Date d){
  553.         DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  554.         return formatter.format(d);
  555.     }
  557.     public static String getDate2YYYYMMdd(Date d){
  558.         DateFormat formatter = new SimpleDateFormat("yyyyMMdd");
  559.         return formatter.format(d);
  560.     }
  564.     /**获取前n个小时的时间 
  565.      * @param date
  566.      * @param hour
  567.      * @return   
  568.      * @author shaosen
  569.      * @Date 2018年9月12日
  570.      */
  571.     public static Date getBeforHour(Date date , int hour) {
  572.         Calendar c = Calendar.getInstance();
  573.         c.setTime(date);
  574.         c.set(Calendar.HOUR_OF_DAY, c.get(Calendar.HOUR_OF_DAY) - hour );
  575.         return c.getTime();
  576.     }
  578.     /**获取后n个小时的时间 
  579.      * @param date
  580.      * @param hour
  581.      * @return   
  582.      * @author shaosen
  583.      * @Date 2018年9月12日
  584.      */
  585.     public static Date getAfterHour(Date date , int hour) {
  586.         Calendar c = Calendar.getInstance();
  587.         c.setTime(date);
  588.         c.set(Calendar.HOUR_OF_DAY, c.get(Calendar.HOUR_OF_DAY) + hour );
  589.         return c.getTime();
  590.     }
  592.     /**获取小时开始时间 
  593.      * @param date
  594.      * @return   
  595.      * @author shaosen
  596.      * @Date 2018年9月12日
  597.      */
  598.     public static Date getHourBeginTime(Date date) {
  599.         Calendar c = Calendar.getInstance();
  600.         c.setTime(date);
  601.         c.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), c.get(Calendar.DAY_OF_MONTH), c.get(Calendar.HOUR_OF_DAY), 0, 0);
  602.         c.set(Calendar.MILLISECOND, 0);
  603.         return c.getTime();
  604.     }
  606.     /**获取小时结束时间 
  607.      * @param date
  608.      * @return   
  609.      * @author shaosen
  610.      * @Date 2018年9月12日
  611.      */
  612.     public static Date getHourEndTime(Date date) {
  613.           Calendar c = Calendar.getInstance();
  614.           c.setTime(date);
  615.           c.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), c.get(Calendar.DAY_OF_MONTH), c.get(Calendar.HOUR_OF_DAY), 59, 59);
  616.           c.set(Calendar.MILLISECOND, 999);
  617.           return c.getTime();
  618.       }
  623.     /**按照周期分别查找 
  624.      * @param em TimeEnum枚举
  625.      * @return   
  626.      * @author shaosen
  627.      * @Date 2018年11月6日
  628.      */
  629.     public static List<Map<String, Date>> getStartTimeAndEndTimeByIntervalvalue(TimeEnum em) {
  630.         List<Map<String, Date>> list = new ArrayList<>();
  631.         if (em == TimeEnum.WEEK) {
  632.             Date beginDayOfWeek = DateUtil.getBeginDayOfWeek();// 获取本周的开始时间
  633.             Map<String, Date> map = new HashMap<>();
  634.             map.put("startDay", beginDayOfWeek);
  635.             map.put("endDay", new Date());
  636.             list.add(map);
  637.             list = getStartTimeAndEndTimeByWeek(beginDayOfWeek, list);
  638.         } else if (em == TimeEnum.MONTH) {
  639.             Date beginDayOfMonth = DateUtil.getBeginDayOfMonth();
  640.             Map<String, Date> map = new HashMap<>();
  641.             map.put("startDay", beginDayOfMonth);
  642.             map.put("endDay", new Date());
  643.             list.add(map);
  644.             list = getStartTimeAndEndTimeByMonth(beginDayOfMonth, list);
  645.         } else if (em == TimeEnum.DAY) {
  646.             Date dayBegin = DateUtil.getDayBegin();
  647.             Map<String, Date> map = new HashMap<>();
  648.             map.put("startDay", dayBegin);
  649.             map.put("endDay", new Date());
  650.             list.add(map);
  651.             list = getStartTimeAndEndTimeByDay(dayBegin, list);
  652.         }
  654.         return list;
  655.     }
  658.     private static List<Map<String, Date>> getStartTimeAndEndTimeByDay(Date date, List<Map<String, Date>> list) {
  659.         Date endDay = DateUtil.getFrontDay(date, 1);// 返回某个日期前几天的日期
  660.         Date startDay = DateUtil.getDayStartTime(endDay);
  662.         if (startDay.after(DateUtil.getBeginDayOfYear())) {
  663.             Map<String, Date> map = new HashMap<>();
  664.             map.put("startDay", startDay);
  665.             map.put("endDay", date);
  666.             list.add(map);
  667.             getStartTimeAndEndTimeByDay(startDay, list);
  668.         } else {
  669.             Map<String, Date> lastMap = new HashMap<>();
  670.             lastMap.put("startDay", DateUtil.getBeginDayOfYear());
  671.             lastMap.put("endDay", date);
  672.             list.add(lastMap);
  673.         }
  674.         return list;
  675.     }
  678.     private static List<Map<String, Date>> getStartTimeAndEndTimeByMonth(Date date, List<Map<String, Date>> list) {
  680.         Date endDay = DateUtil.getFrontDay(date, 1);// 返回某个日期前几天的日期
  681.         Date startDay = DateUtil.getBeginDayOfMonth(endDay);
  683.         if (startDay.after(DateUtil.getBeginDayOfYear())) {
  684.             Map<String, Date> map = new HashMap<>();
  685.             map.put("startDay", startDay);
  686.             map.put("endDay", date);
  687.             list.add(map);
  688.             // 继续找上月开始时间和结束时间
  689.             getStartTimeAndEndTimeByMonth(startDay, list);
  690.         } 
  691.         return list;
  692.     }
  695.     private static List<Map<String, Date>> getStartTimeAndEndTimeByWeek(Date date, List<Map<String, Date>> list) {
  697.         Date endDay = DateUtil.getFrontDay(date, 1);// 返回某个日期前几天的日期
  698.         Date startDay = DateUtil.getBeginDayOfWeek(endDay);
  700.         if (startDay.after(DateUtil.getBeginDayOfYear())) {
  701.             Map<String, Date> map = new HashMap<>();
  702.             map.put("startDay", startDay);
  703.             map.put("endDay", date);
  704.             list.add(map);
  705.             // 继续找上周开始时间和结束时间
  706.             getStartTimeAndEndTimeByWeek(startDay, list);
  707.         } else {
  708.             // 获取本年第一周开始日期和结束日期
  709.             Map<String, Date> lastMap = new HashMap<>();
  710.             lastMap.put("startDay", DateUtil.getBeginDayOfYear());
  711.             lastMap.put("endDay", date);
  712.             list.add(lastMap);
  713.         }
  714.         return list;
  715.     }
  718.     /**获取当月以前共12个月的日期集合
  719.      * @author shaosen
  720.      * @date 2019年1月17日
  721.      * @param   
  722.      * @return List<Map<String,Date>>  
  723.      */
  724.     public static List<Map<String, Date>> getBefore12Months(){
  726.         List<Map<String, Date>> list = new ArrayList<>();
  728.         Date startDay = DateUtil.getBeginDayOfMonth();
  729.         Map<String, Date> map = new HashMap<>();
  730.         map.put("startDay", startDay);
  731.         map.put("endDay", new Date());
  732.         list.add(map);
  734.         for (int i = 1; i < 12; i++) {
  735.             startDay = DateUtil.getBeginDayOfMonth(DateUtil.getFrontDay(startDay, 1));
  736.             Map<String, Date> m = new HashMap<>();
  737.             m.put("startDay", startDay);
  738.             m.put("endDay", DateUtil.getEndDayOfMonth(startDay));
  739.             list.add(m);
  740.         }
  741.         return list;
  742.     }
  744.     public static void main(String[] args) {
  745.         List<Map<String, Date>> list = getBefore12Months();
  746.         for (Map<String, Date> map : list) {
  747.             System.out.println(map.get("startDay"));
  748.             System.out.println(map.get("endDay"));
  749.             System.out.println("--------------------");
  750.         }
  751.     }
  752. }

发表评论

表情：
评论列表 （有 0 条评论，122人围观）

还没有评论，来说两句吧...

相关阅读