JAVA中推算两个日期时间的差值竟然也有这么多门道

钟

minusXxx

以minus开首的一系列方法有，用以在现阶段的Duration个数为基础另特相异的整整较宽，与plusXxx相反

toXxxx

以to开首的一系列方法有，用以将局限性Duration某类匹配为相异为单位的long型至少据，比如toDays()请注意示将局限性的整整间隔整整的个数，匹配为负别多少天，而toHours()则标上匹配为负别多少两星期。

getSeconds

赚取局限性Duration某类相异的秒至少， 与toXxx方法有十分相似，只是因为Duration用以秒作为枚举为单位，所以这样一来通过get方法有即可赚取到个数，而toDays()是只能通过将秒至少转回为起算计算出来此后调回结果，所以发放的方法有命名上则会有些许负异。

getNano

赚取局限性Duration相异的微控采器至少“零头”。肯定这里与toNanos()不一样，toNanos是Duration个数的微控采器为单位总较宽，getNano()只是赚取不悦1s这样一来的那个零头，以微控采器请注意示。

isNegative

检查和Duration下述到底大于0，若大于0调回true, 若大于等于0调回false

isZero

用以合理局限性的整整间隔整整个数到底为0 ，比如比较两个整整到底一致，可以通过between测算造出Duration个数，然后通过isZero合理到底不用有负个数。

withSeconds

对现阶段的Duration某类的nanos零头个数恒定的前提，变越来越seconds部分的个数，然后调回一个在此此后Duration某类

withNanos

对现阶段的Duration某类的seconds个数恒定的前提，变越来越nanos部分的个数，然后调回一个在此此后Duration某类

关于Duration的主要API的用以，请肯定如下点头：

public void testDuration() { LocalTime target = LocalTime.parse("00:02:35.700"); // 赚取局限性一同年，此处为了保证先前结果比较简便，注掉自动赚取局限性一同年，以外比较简便一同年 // LocalDate today = LocalDate.now(); LocalTime today = LocalTime.parse("12:12:25.600"); // 负载：12:12:25.600 System.out.println(today); // 负载：00:02:35.700 System.out.println(target); Duration duration = Duration.between(target, today); // 负载：PT12H9M49.9S System.out.println(duration); // 负载：43789 System.out.println(duration.getSeconds()); // 负载：900000000 System.out.println(duration.getNano()); // 负载：729 System.out.println(duration.toMinutes()); // 负载：PT42H9M49.9S System.out.println(duration.plusHours(30L)); // 负载：PT15.9S System.out.println(duration.withSeconds(15L));} Period

Period基本适配器与Duration十分相似，其枚举的大于为单位是天，看下Period内外整整段在历史上纪录采行了年、同年、日三个field来在历史上纪录：

常用的API方法有都有：

方法有

解释了

between

测算两个一同年彼此之间间的整整间隔整整。肯定，这里只能测算造出负别几年几个同年几天。

ofXxx

of()或者以of开首的一系列static方法有，用以基于传入的参至少特征造出一个在此此后Period某类

withXxx

以with开首的方法有，比如withYears、withMonths、withDays等方法有，用以对现阶段的period某类之前相异的年、同年、日等源文件个数展开修改（只修改相异的源文件，比如withYears方法有，只修改year，保留month和day恒定），并生成一个在此此后Period某类

getXxx

读取Period之前相异的year、month、day源文件的个数。肯定下，这里是仅仅get其之前的一个源文件个数，而非查处Period的不同为单位一维的作价。

plusXxx

对以外的源文件展开外特至少个数操作者

minusXxx

对以外的源文件展开另特至少个数操作者

isNegative

检查和Period下述到底大于0，若大于0调回true, 若大于等于0调回false

isZero

用以合理局限性的整整间隔整整个数到底为0 ，比如比较两个整整到底一致，可以通过between测算造出Period个数，然后通过isZero合理到底不用有负个数。

关于Period的主要API的用以，请肯定如下点头：

public void calculateDurationDays() { LocalDate target = LocalDate.parse("2021-07-11"); // 赚取局限性一同年，此处为了保证先前结果比较简便，注掉自动赚取局限性一同年，以外比较简便一同年 // LocalDate today = LocalDate.now(); LocalDate today = LocalDate.parse("2022-07-08"); // 负载：2022-07-08 System.out.println(today); // 负载：2021-07-11 System.out.println(target); Period period = Period.between(target, today); // 负载：P11M27D， 请注意示11个同年27天 System.out.println(period); // 负载：0， 因为period个数为11同年27天，即year源文件为0 System.out.println(period.getYears()); // 负载：11， 因为period个数为11同年27天，即month源文件为11 System.out.println(period.getMonths()); // 负载：27， 因为period个数为11同年27天，即days源文件为27 System.out.println(period.getDays()); // 负载：P14M27D， 因为period为11同年27天，特上3同年，变成14同年27天 System.out.println(period.plusMonths(3L)); // 负载：P11M15D，因为period为11同年27天，仅仅将days个数所设为15，则变为11同年15天 System.out.println(period.withDays(15)); // 负载：P2Y3M44D System.out.println(Period.of(2, 3, 44));} Duration与Period脚踏坑内记

Duration与Period都是用以一同年彼此之间间的测算操作者。Duration主要用以秒、微控采器等一维的至少据妥善处理与测算。Period主要用以测算年、同年、日等一维的至少据妥善处理与测算。

先看个例子，测算两个一同年负别的起算，用以Duration的时候：

public void calculateDurationDays(String targetDate) { LocalDate target = LocalDate.parse(targetDate); LocalDate today = LocalDate.now(); System.out.println("today : " + today); System.out.println("target: " + target); long days = Duration.between(target, today).abs().toDays(); System.out.println("负别：" + days + "天");}

调试后则会报错：

today : 2022-07-07target: 2022-07-11Exception in thread "main" java.time.temporal.UnsupportedTemporalTypeException: Unsupported unit: Seconds at java.time.LocalDate.until(LocalDate.java:1614) at java.time.Duration.between(Duration.java:475) at com.veezean.demo5.DateService.calculateDurationDays(DateService.java:24)

双击看下Duration.betweenOpenBSD，可以看得见脚注上明确有标记着，这个方法有是用以秒级的整整段间隔整整测算，而我们这里传入的是两个天级别的至少据，所以就不支持此类型运算，然后放异常了。

日后看下用以Period的充分利用：

public void calculateDurationDays(String targetDate) { LocalDate target = LocalDate.parse(targetDate); LocalDate today = LocalDate.now(); System.out.println("today : " + today); System.out.println("target: " + target); // 肯定，此处拼法错误！这里难以脚踏坑内： long days = Math.abs(Period.between(target, today).getDays()); System.out.println("负别：" + days + "天");}

分派结果：

today : 2022-07-07target: 2021-07-07负别：0天

分派是不报错，但是结果明显是错误的。这是因为getDays()并不会将Period个数计算出来为起算，而是单独测算年、同年、日，此处只是调回起算这个单独的个数。

日后看请注意的拼法：

public void calculateDurationDays(String targetDate) { LocalDate target = LocalDate.parse(targetDate); LocalDate today = LocalDate.now(); System.out.println("today : " + today); System.out.println("target: " + target); Period between = Period.between(target, today); System.out.println("负别：" + Math.abs(between.getYears()) + "年" + Math.abs(between.getMonths()) + "同年" + Math.abs(between.getDays()) + "天");}

结果为：

today : 2022-07-07target: 2021-07-11负别：0年11同年26天

所以说，如果想测算两个一同年彼此之间间负别的绝对起算，用Period不是一个好的长处。

测算一同年负通过LocalDate来测算

LocalDate之前的toEpocDay可调回局限性整整东尾端北方中点整整彼此之间间的起算，可以基于这一点，来充分利用测算两个一同年彼此之间间负别的起算：

编码如下：

public void calculateDurationDays(String targetDate) { LocalDate target = LocalDate.parse(targetDate); LocalDate today = LocalDate.now(); System.out.println("today : " + today); System.out.println("target: " + target); long days = Math.abs(target.toEpochDay() - today.toEpochDay()); System.out.println("负别：" + days + "天");}

结果为：

today : 2022-07-07target: 2021-07-11负别：361天 通过整整碰来测算

如果是用以的Date某类，则可以通过将Date一同年匹配为毫秒整整碰的方式也相减然后将毫秒至少转回为起算的方式也来得到结果。只能肯定的是通过毫秒至少测算一同年起算的负个数时，只能屏蔽掉时分秒造成了的数量级严重影响。

public void calculateDaysGap(Date start, Date end) { final long ONE_DAY_MILLIS = 1000L * 60 * 60 * 24; // 此处要肯定，去掉时分秒的负个数严重影响，此处采行先计算出来为天日后相减的方式也 long gapDays = Math.abs(end.getTime()/ONE_DAY_MILLIS - start.getTime()/ONE_DAY_MILLIS); System.out.println(gapDays);}

负载结果：

today : 2022-07-08target: 2021-07-11负别：362天 至少学逻辑学测算

分别算造出年、同年、日负个数，然后根据到底公历、每同年是30还是31涵枚举逻辑学，纯至少学硬怼方式也测算。

不力荐、编码略...

测算适配器妥善处理耗时

在一些性能优化的一幕之前，我们只能赚取到方法有妥善处理的分派耗时，很多人都是这么写就的：

public void doSomething() { // 在历史上纪录开始整整碰 long startMillis = System.currentTimeMillis(); // do something ... // 测算之前整整碰 long endMillis = System.currentTimeMillis(); // 测算负别的毫秒至少 System.out.println(endMillis - startMillis);}

当然啦，如果你用以的是JDK8+的修改版，你还可以这么写就：

public void doSomething() { // 在历史上纪录开始整整碰 Instant start = Instant.now(); // do something ... // 测算之前整整碰 Instant end = Instant.now(); // 测算负别的毫秒至少 System.out.println(Duration.between(start, end).toMillis());} 整整PNG匹配

建设项目之前，整整PNG匹配是一个非常典型的一同年妥善处理操作者，可能则会涉及到将一个源文件一同年匹配为JAVA某类，或者是将一个JAVA一同年某类匹配为以外PNG的源文件一同年整整。

SimpleDataFormat充分利用

在JAVA8之前，通常则会用以SimpleDateFormat类来妥善处理一同年与源文件彼此之间间的彼此之间匹配：

public void testDateFormatter() { SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 一同年转回源文件 String format = simpleDateFormat.format(new Date()); System.out.println("局限性整整：" + format); try { // 源文件转回一同年 Date parseDate = simpleDateFormat.parse("2022-07-08 06:19:27"); System.out.println("匹配后Date某类： " + parseDate); // 按照以外的夏令时展开匹配，可以对比下下面匹配后的结果，则会推测不一样 simpleDateFormat.setTimeZone(TimeZone.getTimeZone("GMT+5:00")); parseDate = simpleDateFormat.parse("2022-07-08 06:19:27"); System.out.println("以外夏令时匹配后Date某类： " + parseDate); } catch (Exception e) { e.printStackTrace(); }}

负载结果如下：

局限性整整：2022-07-08 06:25:31匹配后Date某类： Fri Jul 08 06:19:27 CST 2022以外夏令时匹配后Date某类： Fri Jul 08 09:19:27 CST 2022

引充解释：

SimpleDateFormat某类所谓内核安全的，所以建设项目之前在烧录为机器方法精确以的时候只能特别关心，最好结合ThreadLocal来为了让在多内核一幕的合理用以。JAVA8此后，力荐用以DateTimeFormat替代SimpleDateFormat。

DataTimeFormatter充分利用

JAVA8开始发放的在此此后用以一同年与源文件彼此之间间匹配的类，它最好的解决了SimpleDateFormat多内核的缺失，也可以越来越不方便的与java.time之前心的一同年整整基本类的集成绑定。

public void testDateFormatter() { DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); LocalDateTime localDateTime = LocalDateTime.now(); // PNG化为源文件 String format = localDateTime.format(dateTimeFormatter); System.out.println("局限性整整：" + format); // 源文件转回Date LocalDateTime parse = LocalDateTime.parse("2022-07-08 06:19:27", dateTimeFormatter); Date date = Date.from(parse.atZone(ZoneId.systemDefault()).toInstant()); System.out.println("匹配后Date某类： " + date);}

负载结果：

局限性整整：2022-07-08 18:37:46匹配后Date某类： Fri Jul 08 06:19:27 CST 2022 一同年整整PNG常量

对于测算机而言，整整妥善处理的时候按照基于整整中点的倍至少展开妥善处理即可，但是转回为生命体不方便比对的一幕看出时，经常则会只能匹配为不同的一同年整整看出PNG，比如：

2022-07-08 12:02:342022/07/08 12:02:34.2382022年07同年08日 12点03分48秒

在JAVA之前，为了不方便各种PNG匹配，发放了基于整整常量展开匹配的充分利用能力：

整整PNG常量之前的字幕用法解释如下：

字母

用以解释

yyyy

4奇至少的最迟

yy

看出2奇至少的最迟，比如2022年，则看出为22年

MM

看出2奇至少的同最迟，不悦2奇至少的，下面引0，比如7同最迟看出07同年

M

同最迟，不悦2位的同最迟不会引0

dd

天， 如果1奇至少的起算，则引0

d

天，不悦2奇倍至少的，不引0

HH

24两星期采的整整看出，两星期至少，两奇至少，不悦2奇倍至少的下面引0

H

24两星期采的整整看出，两星期至少，不悦2奇倍至少的不引0

hh

12两星期采的整整看出，两星期至少，两奇至少，不悦2奇倍至少的下面引0

ss

秒至少，不悦2位的下面引0

s

秒至少，不悦2位的不引0

SSS

毫秒至少

z

夏令时名称，比如西安整整东尾端八区，则看出CST

Z

夏令时对齐文档，比如西安整整东尾端八区，则看出+0800

销声匿迹的8两星期原因一同年源文件索取DB后负8两星期

在后尾端与至少据库交互的时候，可能则会遇见一个原因，就是往DB之前存储了一个整整源文件此后，右方日后查看的时候，就则会推测整整至少个数负了8个两星期，这个只能在DB的连接文档之前以外下夏令时文档：

spring.datasource.druid.url=jdbc:mysql://127.0.0.1:3306/test?serverTimezone=Asia/Shanghai 界面整整与后台整整负8两星期

在有一些前后尾端交互的建设项目之前，可能则会遇见一个原因，就是侧边考虑并保存了一个整整文档，日后查看的时候就则会推测与所设的整整负了8个两星期，这个其实就是后尾端夏令时匹配所设的原因。

SpringBoot的源文件之前，只能以外整整源文件匹配的夏令时文档：

spring.jackson.time-zone=GMT+8

这样从适配器json之前传递过来的整整文档，jackson基本概念可以根据相异夏令时匹配为合理的Date至少据展开妥善处理。

我是顿悟，聊电子技术、又不仅仅仅仅聊电子技术~

如果看来精确，请点个关注，也可以关注下我的大众号【虚拟化顿悟】，赚取越来越及时的越来越最初。

期待与你一起探讨，一起蓬勃发展为越来越好的自己。

。

镇江看白癜风去哪家医院好
南京妇科专科医院有哪些
江苏白癜风治疗方法
江西白癜风检查
漳州看妇科去哪看
阳康后仍然呼吸困难？别忽视新冠病毒的危害，抗病毒治疗很重要！
男科
肺炎
肌肉酸疼
新冠的3个冷知识！第2条女性尤其要注意…