java时间工具类

今天药忘吃喽~ 2021-09-28 01:18 448阅读 0赞

在项目中，很多地方需要根据时间获取相应的数据，将时间格式化，或者时间比较等相关操作。一个良好的工具类不仅可以减少代码冗余，还能促进业务处理，加快进度。

  1. /**
  2.  * @author: lxw
  3.  * @Date: 2018/12/25 14:36
  4.  * @Description: 时间工具类
  5.  */
  6. public class DateUtils {
  7.     /**
  8.      * 常用时间格式
  9.      */
  10.     public final static String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
  12.     public final static String MONTH_PATTERN = "yyyy-MM";
  14.     public final static String DATE_PATTERN = "yyyy-MM-dd";
  16.     public final static String HH_MM_SS = "HH:mm:ss";
  18.     public final static String DATE_PATTERN_YYYY_MM_DD_HH_MM = "yyyy-MM-dd HH:mm";
  20.     public static String DATE_TIME_PATTERN_YYYY_MM_DD_HH_MM_SS_SSS = "yyyyMMddHHmmssSSS";
  22.     public static String DATE_TIME_PATTERN_YYYY_MM_DD_HH_MM_SS = "yyyyMMddHHmmss";
  24.     /**
  25.      * 日期转换格式数组
  26.      */
  27.     public static String[][] regularExp = new String[][]{
  29.             // 默认格式
  30.             {"\\d{4}-((([0][1,3-9]|[1][0-2]|[1-9])-([0-2]\\d|[3][0,1]|[1-9]))|((02|2)-(([1-9])|[0-2]\\d)))\\s+([0,1]\\d|[2][0-3]|\\d):([0-5]\\d|\\d):([0-5]\\d|\\d)",
  31.                     DATE_TIME_PATTERN},
  32.             // 仅日期格式 年月日
  33.             {"\\d{4}-((([0][1,3-9]|[1][0-2]|[1-9])-([0-2]\\d|[3][0,1]|[1-9]))|((02|2)-(([1-9])|[0-2]\\d)))",
  34.                     DATE_PATTERN},
  35.             //  带毫秒格式
  36.             {"\\d{4}((([0][1,3-9]|[1][0-2]|[1-9])([0-2]\\d|[3][0,1]|[1-9]))|((02|2)(([1-9])|[0-2]\\d)))([0,1]\\d|[2][0-3])([0-5]\\d|\\d)([0-5]\\d|\\d)\\d{1,3}",
  37.                     DATE_TIME_PATTERN_YYYY_MM_DD_HH_MM_SS_SSS}
  38.     };
  40.     /**
  41.      * 日期转换为String类型
  42.      *
  43.      * @param date    日期
  44.      * @param pattern 获取格式
  45.      * @return String
  46.      */
  47.     public static String format(Date date, String pattern) {
  48.         if (date != null) {
  49.             SimpleDateFormat df = new SimpleDateFormat(pattern);
  50.             return df.format(date);
  51.         }
  52.         return null;
  53.     }
  55.     /**
  56.      * 日期转换为String类型，并添加或减少相应的天数
  57.      *
  58.      * @param date    日期
  59.      * @param pattern 获取格式
  60.      * @param amount  天数
  61.      * @return String
  62.      */
  63.     public static String format(Date date, String pattern, int amount) {
  64.         if (date != null) {
  65.             Calendar calendar = Calendar.getInstance();
  66.             calendar.setTime(date);
  67.             calendar.add(Calendar.DAY_OF_MONTH, amount);
  68.             SimpleDateFormat df = new SimpleDateFormat(pattern);
  69.             return df.format(calendar.getTime());
  70.         }
  71.         return null;
  72.     }
  74.     /**
  75.      * 字符串转换成日期
  76.      *
  77.      * @param strDate 日期字符串
  78.      * @param pattern 日期的格式
  79.      * @return data
  80.      */
  81.     public static Date stringToDate(String strDate, String pattern) {
  82.         if (StringUtils.isBlank(strDate)) {
  83.             return null;
  84.         }
  86.         DateTimeFormatter fmt = DateTimeFormat.forPattern(pattern);
  87.         return fmt.parseLocalDateTime(strDate).toDate();
  88.     }
  90.     /**
  91.      * 两个时间之间的天数
  92.      *
  93.      * @param date1
  94.      * @param date2
  95.      * @param pattern 格式
  96.      * @return 天数
  97.      */
  98.     public static long getDays(String date1, String date2, String pattern) {
  99.         SimpleDateFormat formatter = new SimpleDateFormat(pattern);
  100.         if (date1 == null || date1.equals("")) {
  101.             return 0;
  102.         }
  103.         if (date2 == null || date2.equals("")) {
  104.             return 0;
  105.         }
  106.         try {
  107.             Date date = formatter.parse(date1);
  108.             Date newDate = formatter.parse(date2);
  109.             return (date.getTime() - newDate.getTime()) / (24 * 60 * 60 * 1000);
  110.         } catch (Exception e) {
  111.         }
  112.         return 0;
  113.     }
  115.     /**
  116.      * 产生周序列,即得到当前时间所在的年度是第几周
  117.      *
  118.      * @return
  119.      */
  120.     public static String getSeqWeek() {
  121.         Calendar c = Calendar.getInstance(Locale.CHINA);
  122.         String week = Integer.toString(c.get(Calendar.WEEK_OF_YEAR));
  123.         if (week.length() == 1) {
  124.             week = "0" + week;
  125.         }
  126.         return week;
  127.     }
  129.     /**
  130.      * 日期格式字符串转换成时间戳
  131.      *
  132.      * @param date_str 字符串日期
  133.      * @param format   日期格式，如：yyyy-MM-dd HH:mm:ss
  134.      * @return
  135.      */
  136.     public static String dateTimeStamp(String date_str, String format) {
  137.         try {
  138.             SimpleDateFormat sdf = new SimpleDateFormat(format);
  139.             return String.valueOf(sdf.parse(date_str).getTime() / 1000);
  140.         } catch (Exception e) {
  141.             e.printStackTrace();
  142.         }
  143.         return "";
  144.     }
  146.     /**
  147.      * 获取日期的格式
  148.      *
  149.      * @param date_str 日期格式字符串
  150.      * @return 当前日期格式
  151.      */
  152.     public static String getDateFormat(String date_str) {
  153.         String style = null;
  154.         if (org.springframework.util.StringUtils.isEmpty(date_str)) {
  155.             return null;
  156.         }
  157.         boolean b = false;
  158.         for (int i = 0; i < regularExp.length; i++) {
  159.             b = date_str.matches(regularExp[i][0]);
  160.             if (b) {
  161.                 style = regularExp[i][1];
  162.             }
  163.         }
  164.         if (org.springframework.util.StringUtils.isEmpty(style)) {
  165.             return null;
  166.         }
  167.         return style;
  168.     }
  170.     /**
  171.      * 转换为时间类型格式
  172.      *
  173.      * @param strDate 日期
  174.      * @return
  175.      */
  176.     public static Date strToDate(String strDate) {
  177.         try {
  178.             String strType = getDateFormat(strDate);
  179.             if (strType == null) {
  180.                 return null;
  181.             }
  182.             SimpleDateFormat sf = new SimpleDateFormat(strType);
  183.             return new Date((sf.parse(strDate).getTime()));
  184.         } catch (Exception e) {
  185.             return null;
  186.         }
  187.     }
  189.     /**
  190.      * 获取两个字符串时间差
  191.      *
  192.      * @param beginTime 开始时间
  193.      * @param endTime   结束时间
  194.      * @return xx小时xx分钟
  195.      */
  196.     public static String timeLength(String beginTime, String endTime) {
  197.         if (beginTime == null || "".equals(beginTime)) {
  198.             return "";
  199.         }
  200.         if (endTime == null || "".equals(endTime)) {
  201.             return "";
  202.         }
  203.         Date begin = DateUtils.strToDate(beginTime);
  204.         Date end = DateUtils.strToDate(endTime);
  205.         if (begin == null || end == null) {
  206.             return "";
  207.         }
  208.         try {
  209.             //除以1000是为了转换成秒
  210.             long between = (end.getTime() - begin.getTime()) / 1000;
  211.             int day = (int) between / (24 * 3600);
  212.             int hour = (int) between % (24 * 3600) / 3600;
  213.             int minute = (int) between % 3600 / 60;
  214.             int currentHour = day * 24 + hour;
  215.             return currentHour + "小时" + minute + "分钟";
  216.         } catch (Exception e) {
  217.             return "";
  218.         }
  219.     }
  221.     /**
  222.      * 判断是否润年
  223.      *
  224.      * @param date 日期
  225.      * @return boolean
  226.      */
  227.     public static boolean isLeapYear(Date date) {
  228.         /**
  229.          * 1.被400整除是闰年
  230.          * 2.不能被4整除则不是闰年
  231.          * 3.能被4整除同时不能被100整除则是闰年
  232.          * 4.能被4整除同时能被100整除则不是闰年
  233.          */
  234.         GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
  235.         gc.setTime(date);
  236.         int year = gc.get(Calendar.YEAR);
  237.         if ((year % 400) == 0) {
  238.             return true;
  239.         } else if ((year % 4) == 0) {
  240.             if ((year % 100) == 0) {
  241.                 return false;
  242.             } else {
  243.                 return true;
  244.             }
  245.         } else {
  246.             return false;
  247.         }
  248.     }
  250.     /**
  251.      * 取得当前时间生成格式为yyyymmddhhmmss+k位随机数
  252.      *
  253.      * @param k 随机数位数
  254.      */
  255.     public static String getNo(int k) {
  256.         Date date = new Date();
  257.         return format(date, DATE_TIME_PATTERN_YYYY_MM_DD_HH_MM_SS) + getRandom(k);
  258.     }
  260.     /**
  261.      * 返回一个随机数
  262.      *
  263.      * @param num 随机生成的位数
  264.      * @return
  265.      */
  266.     public static String getRandom(int num) {
  267.         Random random = new Random();
  268.         if (num == 0) {
  269.             return "";
  270.         }
  271.         String randomNum = "";
  272.         for (int i = 0; i < num; i++) {
  273.             //取0-9的随机数进行拼接
  274.             randomNum += random.nextInt(9);
  275.         }
  276.         return randomNum;
  277.     }
  279.   /**
  280.      * 根据周数，获取开始日期、结束日期
  281.      *
  282.      * @param week 周期  0本周，-1上周，-2上上周，1下周，2下下周
  283.      * @return 返回date[0]开始日期、date[1]结束日期
  284.      */
  285.     public static Date[] getWeekStartAndEnd(int week) {
  286.         DateTime dateTime = new DateTime();
  287.         LocalDate date = new LocalDate(dateTime.plusWeeks(week));
  289.         date = date.dayOfWeek().withMinimumValue();
  290.         Date beginDate = date.toDate();
  291.         Date endDate = date.plusDays(6).toDate();
  292.         return new Date[]{beginDate, endDate};
  293.     }
  295.     /**
  296.      * 对日期的【秒】进行加/减
  297.      *
  298.      * @param date    日期
  299.      * @param seconds 秒数，负数为减
  300.      * @return 加/减几秒后的日期
  301.      */
  302.     public static Date addDateSeconds(Date date, int seconds) {
  303.         DateTime dateTime = new DateTime(date);
  304.         return dateTime.plusSeconds(seconds).toDate();
  305.     }
  307.     /**
  308.      * 对日期的【分钟】进行加/减
  309.      *
  310.      * @param date    日期
  311.      * @param minutes 分钟数，负数为减
  312.      * @return 加/减几分钟后的日期
  313.      */
  314.     public static Date addDateMinutes(Date date, int minutes) {
  315.         DateTime dateTime = new DateTime(date);
  316.         return dateTime.plusMinutes(minutes).toDate();
  317.     }
  319.     /**
  320.      * 对日期的【小时】进行加/减
  321.      *
  322.      * @param date  日期
  323.      * @param hours 小时数，负数为减
  324.      * @return 加/减几小时后的日期
  325.      */
  326.     public static Date addDateHours(Date date, int hours) {
  327.         DateTime dateTime = new DateTime(date);
  328.         return dateTime.plusHours(hours).toDate();
  329.     }
  331.     /**
  332.      * 对日期的【天】进行加/减
  333.      *
  334.      * @param date 日期
  335.      * @param days 天数，负数为减
  336.      * @return 加/减几天后的日期
  337.      */
  338.     public static Date addDateDays(Date date, int days) {
  339.         DateTime dateTime = new DateTime(date);
  340.         return dateTime.plusDays(days).toDate();
  341.     }
  343.     /**
  344.      * 对日期的【周】进行加/减
  345.      *
  346.      * @param date  日期
  347.      * @param weeks 周数，负数为减
  348.      * @return 加/减几周后的日期
  349.      */
  350.     public static Date addDateWeeks(Date date, int weeks) {
  351.         DateTime dateTime = new DateTime(date);
  352.         return dateTime.plusWeeks(weeks).toDate();
  353.     }
  355.     /**
  356.      * 对日期的【月】进行加/减
  357.      *
  358.      * @param date   日期
  359.      * @param months 月数，负数为减
  360.      * @return 加/减几月后的日期
  361.      */
  362.     public static Date addDateMonths(Date date, int months) {
  363.         DateTime dateTime = new DateTime(date);
  364.         return dateTime.plusMonths(months).toDate();
  365.     }
  367.     /**
  368.      * 对日期的【年】进行加/减
  369.      *
  370.      * @param date  日期
  371.      * @param years 年数，负数为减
  372.      * @return 加/减几年后的日期
  373.      */
  374.     public static Date addDateYears(Date date, int years) {
  375.         DateTime dateTime = new DateTime(date);
  376.         return dateTime.plusYears(years).toDate();
  377.     }
  379.     /**
  380.      * 比较时间大小
  381.      *
  382.      * @param exprtime 时间1
  383.      * @param times    时间2
  384.      * @return 0:时间相等 1;时间1在时间2之后 -1:时间1在时间2之前
  385.      */
  386.     public static int compareDate(String exprtime, String times) {
  387.         int result = 0;
  388.         //判断时间大小
  389.         if (exprtime != null && !"".equals(exprtime)) {
  390.             DateFormat dateFormat = new SimpleDateFormat(DATE_TIME_PATTERN);
  391.             try {
  392.                 Date d1 = dateFormat.parse(exprtime);
  393.                 Date d2 = dateFormat.parse(times);
  394.                 if (d1.getTime() > d2.getTime()) {
  395.                     System.out.println(d1 + "在" + d2 + "之后");
  396.                     result = 1;
  397.                 } else if (d1.getTime() < d2.getTime()) {
  398.                     result = -1;
  399.                     System.out.println(d1 + "在" + d2 + "之前");
  400.                 } else {
  401.                     System.out.println(d1 + "=" + d2);
  402.                 }
  403.             } catch (ParseException e) {
  404.                 e.printStackTrace();
  405.                 System.out.println("方法——compareDate异常");
  406.             }
  407.         }
  408.         return result;
  409.     }
  411.     /**
  412.      * 获取距离现在的天数
  413.      *
  414.      * @param exprtime 某天的时间字符串
  415.      * @return 天数
  416.      */
  417.     public static long getDays(String exprtime) {
  418.         Date begin = DateUtils.strToDate(format(new Date(), DATE_TIME_PATTERN));
  419.         Date end = DateUtils.strToDate(exprtime);
  420.         long between = (end.getTime() - begin.getTime()) / 1000;
  421.         int day = (int) between / (24 * 3600);
  422.         return day;
  423.     }

测试类方法：

  1. public static void main(String[] args) {
  2.           Date date = new Date();
  3.         String dateString = DateUtils.format(date, DATE_TIME_PATTERN);
  4.         System.out.println("时间格式转换为：" + dateString);
  6.         String tomorrow = DateUtils.format(date, DATE_TIME_PATTERN, 1);
  7.         System.out.println("明天日期：" + tomorrow);
  9.         Date stringToDate = DateUtils.stringToDate(dateString, DATE_TIME_PATTERN);
  10.         System.out.println("当天日期格式：" + stringToDate);
  12.         boolean flag = DateUtils.isLeapYear(date);
  13.         System.out.println("当前是否为闰年：" + flag);
  15.         long days = DateUtils.getDays(tomorrow, dateString, DATE_PATTERN);
  16.         System.out.println("天数相差：" + days + " 天");
  18.         String getSeqWeek = DateUtils.getSeqWeek();
  19.         System.out.println("今年第 " + getSeqWeek + " 周");
  21.         String randomNum = DateUtils.getNo(4);
  22.         System.out.println("编号：" + randomNum);
  24.         String dateTimeStamp = DateUtils.dateTimeStamp(dateString, DATE_TIME_PATTERN);
  25.         System.out.println("当期时间戳：" + dateTimeStamp);
  27.         String timeLength = DateUtils.timeLength(dateString, tomorrow);
  28.         System.out.println("相差时间：" + timeLength);
  30.         String getDateFormat = DateUtils.getDateFormat(dateString);
  31.         System.out.println("当前日期格式：" + getDateFormat);
  33.         String stmpString = DateUtils.stampToDate("1545732716");
  34.         System.out.println("当前日期：" + stmpString);
  36.         String stmpLong = DateUtils.stampToDate(1545732716L);
  37.         System.out.println("当前日期：" + stmpLong);
  39.         long day = DateUtils.getDays("2019-01-01 18:20:20");
  40.         System.out.println("距离当前时间：" + day + "天");
  41.     }

输出结果：

  1. 时间格式转换为：2018-12-25 18:21:23
  2. 明天日期：2018-12-26 18:21:23
  3. 当天日期格式：Tue Dec 25 18:21:23 CST 2018
  4. 当前是否为闰年：false
  5. 天数相差：1 天
  6. 今年第 52 周
  7. 编号：201812251821237084
  8. 当期时间戳：1545733283
  9. 相差时间：24小时0分钟
  10. 当前日期格式：yyyy-MM-dd HH:mm:ss
  11. 当前日期：1970-01-19 05:22:12
  12. 当前日期：1970-01-19 05:22:12
  13. 距离当前时间：6天

该类希望可以满足大部分的业务需求，后续如果还有会继续添加到下文中。

发表评论

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

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

相关阅读

    相关 Java 时间工具类

    借鉴网上资源与工作中经验整理的时间工具类（主要针对java.util.Date的使用，java8后的时间工具下期整理），欢迎大家一起完善补充。 import

    朱雀朱雀/ 0 赞/ 111 阅读

    相关 Java时间工具类

    该时间工具类功能：时间戳格式化至毫秒、时间戳格式化至秒、时间戳格式化至日、时间戳格式化成时和分、Date对象格式化至毫秒、Date对象格式化至秒、Date对象格式化至日、Da

    旧城等待，旧城等待，/ 0 赞/ 382 阅读

    相关 java时间工具类

    在项目中，很多地方需要根据时间获取相应的数据，将时间格式化，或者时间比较等相关操作。一个良好的工具类不仅可以减少代码冗余，还能促进业务处理，加快进度。 /

    今天药忘吃喽~今天药忘吃喽~/ 0 赞/ 449 阅读