时间工具类

  1.  public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
  2.     public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";
  3.     public static final String DEFAULT_DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
  4.  
  5.     /**
  6.      * 格式化后的日期字符串，默认使用 yyyy-MM-dd HH:mm:ss
  7.      * @param localDateTime
  8.      * @return formatDateToString
  9.      */
  10.     public static String formatDateToString(LocalDateTime localDateTime){
  11.         return localDateTime.format(DateTimeFormatter.ofPattern(DEFAULT_DATETIME_FORMAT));
  12.     }
  13.  
  14.     /**
  15.      * 根据给定的格式把时间转换为字符串
  16.      * @param localDateTime 要格式化的日期
  17.      * @param format 转换格式
  18.      * @return formatDateToString
  19.      */
  20.     public static String formatDateToString(LocalDateTime localDateTime , String format){
  21.         if (null != localDateTime){
  22.             return localDateTime.format(DateTimeFormatter.ofPattern(format));
  23.         } else {
  24.             return null;
  25.         }
  26.     }
  27.  
  28.     /**
  29.      * 字符转换为时间，默认使用yyyy-MM-dd HH:mm:ss格式
  30.      * @param date
  31.      * @return LocalDateTime
  32.      */
  33.     public static LocalDateTime formatStringToDate(String date){
  34.         DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(DEFAULT_DATETIME_FORMAT);
  35.         return LocalDateTime.parse(date,dateTimeFormatter);
  36.     }
  37.  
  38.     /**
  39.      * 字符转换为时间，默认使用yyyy-MM-dd HH:mm:ss格式
  40.      * @param data 日期字符串
  41.      * @param format 转换格式
  42.      * @return LocalDateTime
  43.      */
  44.     public static LocalDateTime formatStringToDate(String data,String format){
  45.         if (null != data && ! data.equals("")){
  46.             DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
  47.             return LocalDateTime.parse(data,dateTimeFormatter);
  48.         } else {
  49.             return null;
  50.         }
  51.     }
  52.  
  53.     /**
  54.      * 将LocalDateTime转为long类型的timestamp
  55.      * @param localDateTime
  56.      * @return long
  57.      */
  58.     public static long getTimestampOfDateTime(LocalDateTime localDateTime){
  59.         ZoneId zoneId = ZoneId.systemDefault();
  60.         Instant instant = localDateTime.atZone(zoneId).toInstant();
  61.         return instant.toEpochMilli();
  62.     }
  63.  
  64.     /**
  65.      * 将long类型的timestamp转为LocalDateTime
  66.      * @param timestamp
  67.      * @return LocalDateTime
  68.      */
  69.     public static LocalDateTime getDateTimeOfTimestamp(long timestamp){
  70.         Instant instant = Instant.ofEpochMilli(timestamp);
  71.         ZoneId zoneId = ZoneId.systemDefault();
  72.         return LocalDateTime.ofInstant(instant,zoneId);
  73.     }
  74.  
  75.     /**
  76.      * 判断一个日期是否在指定日期之后
  77.      * @param data 要比较的日期
  78.      * @param afterData 指定的日期
  79.      * @param format 格式
  80.      * @return boolean
  81.      */
  82.     public static boolean isAfter(String data , String afterData , String format){
  83.         DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
  84.         LocalDateTime datas = LocalDateTime.parse(data,dateTimeFormatter);
  85.         LocalDateTime afterDa = LocalDateTime.parse(afterData , dateTimeFormatter);
  86.         return datas.isAfter(afterDa);
  87.     }
  88.  
  89.     /**
  90.      * 判断一个日期是否在指定日期之前
  91.      * @param data 要比较的日期
  92.      * @param before 指定的日期
  93.      * @param format 格式
  94.      * @return boolean
  95.      */
  96.     public static boolean isBefore(String data,String before ,String format){
  97.         DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
  98.         LocalDateTime datas = LocalDateTime.parse(data,dateTimeFormatter);
  99.         LocalDateTime afterDa = LocalDateTime.parse(before , dateTimeFormatter);
  100.         return datas.isBefore(afterDa);
  101.     }
  102.  
  103.     /**
  104.      * 判断是否为闰年
  105.      * @param data 日期 格式:yyyy-MM-dd
  106.      * @return boolean
  107.      */
  108.     public static boolean isLeapYear(String data){
  109.         LocalDate yeat = LocalDate.parse(data);
  110.         return yeat.isLeapYear();
  111.     }
  112.  
  113.     /**
  114.      * 判断是否为闰年
  115.      * @param localDate 日期 格式:yyyy-MM-dd
  116.      * @return boolean
  117.      */
  118.     public static boolean isLeapYear(LocalDate localDate){
  119.         return localDate.isLeapYear();
  120.     }
  121.  
  122.     /**
  123.      *  当前时间加减年
  124.      * @param years 年
  125.      * @return
  126.      */
  127.     public static LocalDateTime plusYears(int years){
  128.         LocalDateTime localDateTime = LocalDateTime.now();
  129.         return localDateTime.plusYears(years);
  130.     }
  131.  
  132.     /**
  133.      *  当前时间加减月
  134.      * @param months 月份
  135.      * @return
  136.      */
  137.     public static LocalDateTime plusMonths(int months){
  138.         LocalDateTime localDateTime = LocalDateTime.now();
  139.         return localDateTime.plusMonths(months);
  140.     }
  141.  
  142.     /**
  143.      *  当前时间加减日
  144.      * @param days 日
  145.      * @return
  146.      */
  147.     public static LocalDateTime plusDays(int days){
  148.         LocalDateTime localDateTime = LocalDateTime.now();
  149.         return localDateTime.plusDays(days);
  150.     }
  151.  
  152.     /**
  153.      *  当前时间加减星期
  154.      * @param weeks 星期
  155.      * @return
  156.      */
  157.     public static LocalDateTime plusWeeks(int weeks){
  158.         LocalDateTime localDateTime = LocalDateTime.now();
  159.         return localDateTime.plusWeeks(weeks);
  160.     }
  161.  
  162.     /**
  163.      * 当前时间加上几个小时，传入负数减去对应的时间
  164.      * @param hours 时间：单位小时
  165.      * @return LocalDateTime
  166.      */
  167.     public static LocalDateTime plusHours(int hours){
  168.         LocalDateTime localDateTime = LocalDateTime.now();
  169.         return localDateTime.plusHours(hours);
  170.     }
  171.  
  172.     /**
  173.      * 当前时间加上几分钟，传入负数减去对应的时间
  174.      * @param minutes 时间：单位分钟
  175.      * @return LocalDateTime
  176.      */
  177.     public static LocalDateTime plusMinutes(int minutes){
  178.         LocalDateTime localDateTime = LocalDateTime.now();
  179.         return localDateTime.plusMinutes(minutes);
  180.     }
  181.  
  182.     /**
  183.      * 当前时间加上几秒钟，传入负数减去对应的时间
  184.      * @param seconds 时间：单位秒
  185.      * @return LocalDateTime
  186.      */
  187.     public static LocalDateTime plusSeconds(int seconds){
  188.         LocalDateTime localDateTime = LocalDateTime.now();
  189.         return localDateTime.plusSeconds(seconds);
  190.     }
  191.  
  192.     /**
  193.      * 修改当前时间的小时
  194.      * @param hour 时间：单位小时
  195.      * @return LocalDateTime
  196.      */
  197.     public static LocalDateTime withHour(int hour){
  198.         LocalDateTime localDateTime = LocalDateTime.now();
  199.         return localDateTime.withHour(hour);
  200.     }
  201.  
  202.     /**
  203.      * 修改当前时间的分钟
  204.      * @param minute 时间：单位分钟
  205.      * @return LocalDateTime
  206.      */
  207.     public static LocalDateTime withMinute(int minute){
  208.         LocalDateTime localDateTime = LocalDateTime.now();
  209.         return localDateTime.withMinute(minute);
  210.     }
  211.  
  212.     /**
  213.      * 修改当前时间的秒
  214.      * @param second 时间：单位秒
  215.      * @return LocalDateTime
  216.      */
  217.     public static LocalDateTime withSecond(int second){
  218.         LocalDateTime localDateTime = LocalDateTime.now();
  219.         return localDateTime.withSecond(second);
  220.     }
  221.  
  222.     /**
  223.      * 给指定的时间加年
  224.      * @param data 指定时间
  225.      * @param years 要加上的年份负数为减去
  226.      * @return LocalDateTime
  227.      */
  228.     public static LocalDateTime addYears(String data , int years){
  229.         LocalDateTime localDateTime = formatStringToDate(data);
  230.         return localDateTime.plusYears(years);
  231.     }
  232.  
  233.     /**
  234.      * 给指定的时间加月
  235.      * @param data 指定时间
  236.      * @param months 要加上的月负数为减去
  237.      * @return LocalDateTime
  238.      */
  239.     public static LocalDateTime addMonths(String data , int months){
  240.         LocalDateTime localDateTime = formatStringToDate(data);
  241.         return localDateTime.plusMonths(months);
  242.     }
  243.  
  244.     /**
  245.      * 给指定的时间加日
  246.      * @param data 指定时间
  247.      * @param days 要加上的日负数为减去
  248.      * @return LocalDateTime
  249.      */
  250.     public static LocalDateTime addDays(String data , int days){
  251.         LocalDateTime localDateTime = formatStringToDate(data);
  252.         return localDateTime.plusDays(days);
  253.     }
  254.  
  255.     /**
  256.      * 给指定的时间加星期
  257.      * @param data 指定时间
  258.      * @param weeks 要加上的星期负数为减去
  259.      * @return LocalDateTime
  260.      */
  261.     public static LocalDateTime addWeeks(String data, int weeks){
  262.         LocalDateTime localDateTime = formatStringToDate(data);
  263.         return localDateTime.plusWeeks(weeks);
  264.     }
  265.  
  266.     /**
  267.      * 给指定时间加小时
  268.      * @param data 指定时间
  269.      * @param hour 要加上的小时负数为减去
  270.      * @return LocalDateTime
  271.      */
  272.     public static LocalDateTime addHours(String data , int hour){
  273.         LocalDateTime localDateTime = formatStringToDate(data);
  274.         return localDateTime.plusHours(hour);
  275.     }
  276.  
  277.     /**
  278.      * 给指定时间加分钟
  279.      * @param data 指定时间
  280.      * @param minutes 要加上的分钟负数为减去
  281.      * @return LocalDateTime
  282.      */
  283.     public static LocalDateTime addMinutes(String data , int minutes){
  284.         LocalDateTime localDateTime = formatStringToDate(data);
  285.         return localDateTime.plusMinutes(minutes);
  286.     }
  287.  
  288.     /**
  289.      * 给指定时间加秒
  290.      * @param data 指定时间
  291.      * @param seconds 要加上的秒负数为减去
  292.      * @return LocalDateTime
  293.      */
  294.     public static LocalDateTime addSeconds(String data , int seconds){
  295.         LocalDateTime localDateTime = formatStringToDate(data);
  296.         return localDateTime.plusSeconds(seconds);
  297.     }
  298.  
  299.     /**
  300.      * 计算两个时间相差多少年，结果为负数说明前面的时间比后面的时间大
  301.      * @param time1 时间一
  302.      * @param time2 时间二
  303.      * @return long
  304.      */
  305.     public static long minusYears(String time1 ,String time2){
  306.         LocalDateTime localDateTime = formatStringToDate(time1);
  307.         LocalDateTime localDateTime2 = formatStringToDate(time2);
  308.         return ChronoUnit.YEARS.between(localDateTime,localDateTime2);
  309.     }
  310.  
  311.     /**
  312.      * 计算两个时间相差多少月，结果为负数说明前面的时间比后面的时间大
  313.      * @param time1 时间一
  314.      * @param time2 时间二
  315.      * @return long
  316.      */
  317.     public static long minusMonths(String time1 ,String time2){
  318.         LocalDateTime localDateTime = formatStringToDate(time1);
  319.         LocalDateTime localDateTime2 = formatStringToDate(time2);
  320.         return ChronoUnit.MONTHS.between(localDateTime,localDateTime2);
  321.     }
  322.  
  323.     /**
  324.      * 计算两个时间相差多少天，结果为负数说明前面的时间比后面的时间大
  325.      * @param time1 时间一
  326.      * @param time2 时间二
  327.      * @return long
  328.      */
  329.     public static long minusDays(String time1 ,String time2){
  330.         LocalDateTime localDateTime = formatStringToDate(time1);
  331.         LocalDateTime localDateTime2 = formatStringToDate(time2);
  332.         return ChronoUnit.DAYS.between(localDateTime,localDateTime2);
  333.     }
  334.  
  335.     /**
  336.      * 计算两个时间相差多少星期，结果为负数说明前面的时间比后面的时间大
  337.      * @param time1 时间一
  338.      * @param time2 时间二
  339.      * @return long
  340.      */
  341.     public static long minusWeeks(String time1 ,String time2){
  342.         LocalDateTime localDateTime = formatStringToDate(time1);
  343.         LocalDateTime localDateTime2 = formatStringToDate(time2);
  344.         return ChronoUnit.WEEKS.between(localDateTime,localDateTime2);
  345.     }
  346.  
  347.     /**
  348.      * 计算两个时间相差多少小时，结果为负数说明前面的时间比后面的时间大
  349.      * @param time1 时间一
  350.      * @param time2 时间二
  351.      * @return long
  352.      */
  353.     public static long minusHours(String time1 ,String time2){
  354.         LocalDateTime localDateTime = formatStringToDate(time1);
  355.         LocalDateTime localDateTime2 = formatStringToDate(time2);
  356.         return ChronoUnit.HOURS.between(localDateTime,localDateTime2);
  357.     }
  358.  
  359.     /**
  360.      * 计算两个时间相差多少分钟，结果为负数说明前面的时间比后面的时间大
  361.      * @param time1 时间一
  362.      * @param time2 时间二
  363.      * @return long
  364.      */
  365.     public static long minusMinutes(String time1 ,String time2){
  366.         LocalDateTime localDateTime = formatStringToDate(time1);
  367.         LocalDateTime localDateTime2 = formatStringToDate(time2);
  368.         return ChronoUnit.MINUTES.between(localDateTime,localDateTime2);
  369.     }
  370.  
  371.     /**
  372.      * 计算两个时间相差多少秒，结果为负数说明前面的时间比后面的时间大
  373.      * @param time1 时间一
  374.      * @param time2 时间二
  375.      * @return long
  376.      */
  377.     public static long minusSeconds(String time1 ,String time2){
  378.         LocalDateTime localDateTime = formatStringToDate(time1);
  379.         LocalDateTime localDateTime2 = formatStringToDate(time2);
  380.         return ChronoUnit.MINUTES.between(localDateTime,localDateTime2);
  381.     }
  382.  
  383.     /**
  384.      * 获取传入时间的年份
  385.      * @param localDateTime 时间
  386.      * @return
  387.      */
  388.     public static int getYear(LocalDateTime localDateTime){
  389.         return localDateTime.getYear();
  390.     }
  391.  
  392.     /**
  393.      * 获取传入时间的月份
  394.      * @param localDateTime 时间
  395.      * @return
  396.      */
  397.     public static int getMonth(LocalDateTime localDateTime){
  398.         return MyMonth.getMonth(localDateTime.getMonth().toString());
  399.     }
  400.  
  401.     /**
  402.      * 获取传入时间的日
  403.      * @param localDateTime 时间
  404.      * @return
  405.      */
  406.     public static int getDay(LocalDateTime localDateTime){
  407.         return localDateTime.getDayOfMonth();
  408.     }
  409.  
  410.     /**
  411.      * 获取传入时间是星期几
  412.      * @param localDateTime 时间
  413.      * @return Integer
  414.      */
  415.     public static Integer getWeek(LocalDateTime localDateTime){
  416.         return MyDayOfWeek.getDayWeek(localDateTime.getDayOfWeek().toString());
  417.     }
  418.  
  419.     /**
  420.      * 获取传入时间是一年中的第几天
  421.      * @param localDateTime 时间
  422.      * @return Integer
  423.      */
  424.     public static Integer getDayOfYear(LocalDateTime localDateTime){
  425.         return localDateTime.getDayOfYear();
  426.     }
  427.  
  428.     /**
  429.      * 获取传入时间的时
  430.      * @param localDateTime 时间
  431.      * @return
  432.      */
  433.     public static int getHour(LocalDateTime localDateTime){
  434.         return localDateTime.getHour();
  435.     }
  436.  
  437.     /**
  438.      * 获取传入时间的分
  439.      * @param localDateTime 时间
  440.      * @return
  441.      */
  442.     public static int getMinutes(LocalDateTime localDateTime){
  443.         return localDateTime.getMinute();
  444.     }
  445.  
  446.     /**
  447.      * 获取传入时间的秒
  448.      * @param localDateTime 时间
  449.      * @return
  450.      */
  451.     public static int getSeconds(LocalDateTime localDateTime){
  452.         return localDateTime.getSecond();
  453.     }

　　另外加上两个附带使用到的工具类，在获取月份和星期的时候使用

  1. package com.xy.studyboot.util;
  2.  
  3. /**
  4.  * WJY
  5.  */
  6. public enum MyMonth {
  7.  
  8.     JANUARY(1,"JANUARY"),
  9.     FEBRUARY(2,"FEBRUARY"),
  10.     MARCH(3,"MARCH"),
  11.     APRIL(4,"APRIL"),
  12.     MAY(5,"MAY"),
  13.     JUNE(6,"JUNE"),
  14.     JULY(7,"JULY"),
  15.     AUGUST(8,"AUGUST"),
  16.     SEPTEMBER(9,"SEPTEMBER"),
  17.     OCTOBER(10,"OCTOBER"),
  18.     NOVEMBER(11,"NOVEMBER"),
  19.     DECEMBER(12,"DECEMBER");
  20.  
  21.     private int month;
  22.  
  23.     private String value;
  24.  
  25.     private MyMonth(int month,String value){
  26.         this.month = month;
  27.         this.value = value;
  28.     }
  29.  
  30.     public static Integer getMonth(String value){
  31.         for (MyMonth myMonth: MyMonth.values()){
  32.             if (myMonth.getValue().equals(value)){
  33.                 return myMonth.getMonth();
  34.             }
  35.         }
  36.         return null;
  37.     }
  38.  
  39.     public int getMonth() {
  40.         return month;
  41.     }
  42.  
  43.     public String getValue() {
  44.         return value;
  45.     }
  46. }

　

  1. package com.xy.studyboot.util;
  2.  
  3. /**
  4.  * WJY
  5.  */
  6. public enum MyDayOfWeek {
  7.  
  8.     MONDAY(1,"MONDAY"),
  9.     TUESDAY(2,"TUESDAY"),
  10.     WEDNESDAY(3,"WEDNESDAY"),
  11.     THURSDAY(4,"THURSDAY"),
  12.     FRIDAY(5,"FRIDAY"),
  13.     SATURDAY(6,"SATURDAY"),
  14.     SUNDAY(7,"SUNDAY");
  15.  
  16.     private int day;
  17.  
  18.     private String value;
  19.  
  20.     private MyDayOfWeek(int day , String value){
  21.         this.day = day;
  22.         this.value = value;
  23.     }
  24.  
  25.     public static Integer getDayWeek(String value){
  26.         for (MyDayOfWeek dayOfWeek : MyDayOfWeek.values()){
  27.             if (dayOfWeek.getValue().equals(value)){
  28.                 return dayOfWeek.getDay();
  29.             }
  30.         }
  31.         return null;
  32.     }
  33.  
  34.     public int getDay() {
  35.         return day;
  36.     }
  37.  
  38.     public String getValue() {
  39.         return value;
  40.     }
  41.  
  42. }

　　

jdk1.8 时间工具类，可以满足基本操作的更多相关文章

  1. 代码片段：基于 JDK 8 time包的时间工具类 TimeUtil

    摘要: 原创出处:www.bysocket.com 泥瓦匠BYSocket 希望转载,保留摘要,谢谢! “知识的工作者必须成为自己时间的首席执行官.” 前言 这次泥瓦匠带来的是一个好玩的基于 JDK ...

  2. Java日期工具类，Java时间工具类，Java时间格式化

    Java日期工具类,Java时间工具类,Java时间格式化 >>>>>>>>>>>>>>>>>&g ...

  3. 小记Java时间工具类

    小记Java时间工具类 废话不多说,这里主要记录以下几个工具 两个时间只差(Data) 获取时间的格式 格式化时间 返回String 两个时间只差(String) 获取两个时间之间的日期.月份.年份 ...

  4. 超详细的Java时间工具类

    package com.td.util; import java.sql.Timestamp; import java.text.ParseException; import java.text.Pa ...

  5. java时间工具类

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

  6. 基于Java8的日期时间工具类DateTimeFormatter

    原文:https://blog.csdn.net/qq_36596145/article/details/85331002 import java.time.Instant; import java. ...

  7. Apache Commons Lang之日期时间工具类

    码农不识Apache,码尽一生也枉然. FastDateFormat FastDateFormat是一个快速且线程安全的时间操作类,它完全可以替代SimpleDateFromat.因为是线程安全的,所 ...

  8. Java8 ,LocalDate，LocalDateTime处理日期和时间工具类，

    Java8 ,LocalDate,LocalDateTime处理日期和时间工具类 1.获取今天的日期 2.在Java 8 中获取年.月.日信息 3.在Java 8 中处理特定日期 4.在Java 8 ...

  9. java8时间类API安全问题(赠送新的时间工具类哟)

    LocalDateTime等新出的日期类全是final修饰的类,不能被继承,且对应的日期变量都是final修饰的,也就是不可变类.赋值一次后就不可变,不存在多线程数据问题. simpleDateFor ...

随机推荐

  1. 树莓派4B的CPU系统里查到为BCM2835而非BCM2711

    树莓派4B采用四核64位的ARM Cortex-A72架构CPU,型号为博通BCM2711 SoC.2711是个64位的四核,而2835是多年前的32位单核CPU. 查看当前芯片版本,显示为4核心,但 ...

  2. CSRF 学习笔记

    1:什么是CSRF: 假设有一个支付网站:www.xx.com 向小明同学付款1000元数据包: www.xx.com/pay.php?name=xiaoming&account=xxxx@q ...

  3. 解决CocoaPods could not find compatible versions for pod "React/Core"

    react-native框架中,在ios文件夹下执行pod install命令时出现的问题. 下面时完整的异常信息: [!] CocoaPods could not find compatible v ...

  4. Visual Studio Code中设置sftp同步代码到服务器

    ## **前言** - 绝对的大佬才会直接在Linux下用vim写代码,我等小白只能通过IDE来了,所以将代码同步到服务器上就很重要了.使用vs code设置好sftp就可以实现这一功能. - 设置之 ...

  5. 2020-05-25：MQ应用场景、Kafka和rabbit区别?kafka为什么支撑高并发？ 来自

    福哥答案2020-05-25: 应用场景:解耦.异步.削峰.区别如下:特性 ActiveMQ RabbitMQ RocketMQ Kafka单机吞吐量 万级,比 RocketMQ.Kafka 低一个数 ...

  6. effectivejava(破坏单例)

    以下代码是最普通的双重锁的单例实现形式 package com.edu.character02; import java.io.Serializable; /** * <p> * 双重锁 ...

  7. Java并发编程(07)：Fork/Join框架机制详解

    本文源码:GitHub·点这里 || GitEE·点这里 一.Fork/Join框架 Java提供Fork/Join框架用于并行执行任务,核心的思想就是将一个大任务切分成多个小任务,然后汇总每个小任务 ...

  8. 虚拟化技术之kvm磁盘管理工具qemu-img

    在前边的博客中,我们大致了解了virsh这个工具对kvm虚拟机的一些操作,回顾请参考https://www.cnblogs.com/qiuhom-1874/tag/virsh/:今天我们来了解下kvm ...

  9. Jmeter 常用函数（27）- 详解 __env

    如果你想查看更多 Jmeter 常用函数可以在这篇文章找找哦 https://www.cnblogs.com/poloyy/p/13291704.html 作用 获取环境变量的值 语法格式 ${__e ...

  10. linux,运维,部署 相关

    基础 linux基础命令 linux基础 部署 docker