Java 8：多个单位中两个 LocalDateTime 之间的差异
Posted
技术标签:
【中文标题】Java 8：多个单位中两个 LocalDateTime 之间的差异【英文标题】：Java 8: Difference between two LocalDateTime in multiple units 【发布时间】：2014-11-03 01:04:13 【问题描述】：我正在尝试计算两个LocalDateTime 之间的差异。
输出的格式必须为y years m months d days h hours m minutes s seconds。这是我写的：
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.Period;
import java.time.ZoneId;
public class Main
static final int MINUTES_PER_HOUR = 60;
static final int SECONDS_PER_MINUTE = 60;
static final int SECONDS_PER_HOUR = SECONDS_PER_MINUTE * MINUTES_PER_HOUR;
public static void main(String[] args)
LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 9, 19, 46, 45);
LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55);
Period period = getPeriod(fromDateTime, toDateTime);
long time[] = getTime(fromDateTime, toDateTime);
System.out.println(period.getYears() + " years " +
period.getMonths() + " months " +
period.getDays() + " days " +
time[0] + " hours " +
time[1] + " minutes " +
time[2] + " seconds.");
private static Period getPeriod(LocalDateTime dob, LocalDateTime now)
return Period.between(dob.toLocalDate(), now.toLocalDate());
private static long[] getTime(LocalDateTime dob, LocalDateTime now)
LocalDateTime today = LocalDateTime.of(now.getYear(),
now.getMonthValue(), now.getDayOfMonth(), dob.getHour(), dob.getMinute(), dob.getSecond());
Duration duration = Duration.between(today, now);
long seconds = duration.getSeconds();
long hours = seconds / SECONDS_PER_HOUR;
long minutes = ((seconds % SECONDS_PER_HOUR) / SECONDS_PER_MINUTE);
long secs = (seconds % SECONDS_PER_MINUTE);
return new long[]hours, minutes, secs;
我得到的输出是29 years 8 months 24 days 12 hours 0 minutes 50 seconds。我检查了这个website 的结果（值12/16/1984 07:45:55 和09/09/2014 19:46:45）。以下屏幕截图显示了输出：
我很确定月份值之后的字段在我的代码中是错误的。任何建议都会非常有帮助。
更新
我已经从另一个网站测试了我的结果，但我得到的结果不同。这里是：Calculate duration between two dates（结果：29 年 8 个月 24 天 12 小时 0 分 50 秒）。
更新
由于我从两个不同的站点得到了两个不同的结果，我想知道我的计算算法是否合法。如果我使用以下两个 LocalDateTime 对象：
LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 40, 45);
LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55);
那么输出来了：29 years 8 months 25 days -1 hours -5 minutes -10 seconds.
从这个link 应该是29 years 8 months 24 days 22 hours, 54 minutes and 50 seconds。所以算法也需要处理负数。
请注意，问题不在于哪个网站给了我什么结果，我需要知道正确的算法并且需要有正确的结果。
【问题讨论】：
只是猜测，但Period.between() 可能会应用一些舍入？
我刚刚又看了一遍代码，网站似乎有误（请自行计算）。如果您省略日期，即年、月和日的差异，您将获得开始时间7:45:55 和结束时间19:46:45（或7:46:45 PM）。所以这两个时间之间的差异是 12 小时 0 分 50 秒和 从不 23 小时 34 分 12 秒。所以你的计算结果似乎是正确的，至少在时间部分是正确的。
那个网站上的有趣现象：开始日期加上 10 年，小时差从 23 变为 8 - 肯定是错误的迹象。
请注意，由于LocalDateTime 没有时区，因此可能没有唯一的答案。即使您假设开始时区和结束时区相同，在某些区域日期（如 2014-09-09）将采用夏令时或夏令时，而在其他区域则不会。这可能会把事情耽误一个小时。因此，除非解决此问题，否则计算与秒的差异是没有意义的。
您是否理解使用LocalDateTime 会产生不切实际的结果，因为该类故意缺少任何时区或与UTC 偏移的概念？对于实际值，请通过ZoneId 分配时区以使用ZonedDateTime。
【参考方案1】：
不幸的是，似乎没有跨时间的时期类，因此您可能必须自己进行计算。
幸运的是，日期和时间类有很多实用方法可以在一定程度上简化它。下面是一种计算差异的方法，虽然不一定是最快的：
LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55);
LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 40, 45);
LocalDateTime tempDateTime = LocalDateTime.from( fromDateTime );
long years = tempDateTime.until( toDateTime, ChronoUnit.YEARS );
tempDateTime = tempDateTime.plusYears( years );
long months = tempDateTime.until( toDateTime, ChronoUnit.MONTHS );
tempDateTime = tempDateTime.plusMonths( months );
long days = tempDateTime.until( toDateTime, ChronoUnit.DAYS );
tempDateTime = tempDateTime.plusDays( days );
long hours = tempDateTime.until( toDateTime, ChronoUnit.HOURS );
tempDateTime = tempDateTime.plusHours( hours );
long minutes = tempDateTime.until( toDateTime, ChronoUnit.MINUTES );
tempDateTime = tempDateTime.plusMinutes( minutes );
long seconds = tempDateTime.until( toDateTime, ChronoUnit.SECONDS );
System.out.println( years + " years " +
months + " months " +
days + " days " +
hours + " hours " +
minutes + " minutes " +
seconds + " seconds.");
//prints: 29 years 8 months 24 days 22 hours 54 minutes 50 seconds.
基本思想是这样的：创建一个临时的开始日期，然后将整年计算到结束。然后按年数调整该日期，使开始日期比结束日期少一年。按降序对每个时间单位重复此操作。
最后一个免责声明：我没有考虑不同的时区（两个日期应该在同一个时区），我也没有测试/检查夏令时或其他变化日历（如萨摩亚的时区变化）会影响此计算。所以要小心使用。
【讨论】：
你有相同的基本想法，因此我赞成，但请尝试使用相同的输入，否则不同的结果会令人困惑。 @MenoHochschild 它是相同的输入，只是取自 OP 存在负时间问题的更新。 ;) 算法不错，但类型错误（参见 Thomas 免责声明）。在进行计算之前，您应该使用默认时区（或您需要的任何时区）将 LocalDateTime 变量转换为 ZonedDateTime： ZonedDateTime fromZonedDateTime = fromDateTime.atZone(ZoneId.systemDefault()); @Thomas 您的示例也在使用 Java 8 - 问题被标记为 java-8。实际上，您的示例甚至使用ChronoUnit :) 而是“手动”完成工作。
@EugeneBeresovsky 哦，是的，你是对的。完全错过了 ;) - 除此之外，您仍然必须从间隔中减去较大的单位，因为例如 long minutes = ChronoUnit.MINUTES.between(fromDate, toDate); 将在至少 1 小时的任何间隔内返回大于 59 的数字 - 这不是 OP想要。考虑到这一点，您不能只拨打 6 次电话到 ChronoUnit#between() 就完成了。【参考方案2】：
我发现最好的方法是使用 ChronoUnit。
long minutes = ChronoUnit.MINUTES.between(fromDate, toDate);
long hours = ChronoUnit.HOURS.between(fromDate, toDate);
其他文档在这里：https://docs.oracle.com/javase/tutorial/datetime/iso/period.html
【讨论】：
我没有看到真正的改进。与接受的 Thomas 的答案相比，您只需将tempDateTime.until( toDateTime, ChronoUnit.YEARS) 替换为 ChronoUnit.YEARS.between(fromDate, toDate)。但是您的答案中完全缺少诸如tempDateTime.plusYears( years ) 等重要的附加行，因此它对OP没有帮助。完整的算法很重要！
我更喜欢这个，因为它更简洁，更易读。这是找出两个日期之间差异的最佳方法。
@SomaiahKumbera 不，您完全错过了关键点。 OP 不希望只有一个单元而是多个单元的持续时间，因此这个答案根本不是一个真正的答案。 OP 的担忧根本没有得到解决。请再次阅读这个问题。 （很多支持者似乎误解了这个问题）。
@MenoHochschild，我认为您实际上是缺少关键点的人。 OP在一年前得到了他们的答案。正在查看此问题的 36000 人并不关心 OP 的具体问题。他们是由谷歌领导的，我的回答为他们提供了他们正在寻找的东西 - 一个干净简单的解决方案，用于获取两个日期之间的差异。
我需要两个日期时间之间的秒差并开始实施我自己的解决方案。不久它似乎很复杂，我接受了谷歌。 satnam 的答案可能无法回答 OP 问题，但肯定对我有很大帮助，而且我敢打赌，很多人都和我一样。【参考方案3】：
Tapas Bose 代码和 Thomas 代码存在一些问题。如果时间差为负，则数组获取负值。例如，如果
LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 46, 45);
LocalDateTime fromDateTime = LocalDateTime.of(2014, 9, 9, 7, 46, 45);
它返回 0 年 0 个月 1 天 -1 小时 0 分钟 0 秒。
我认为正确的输出是：0 年 0 个月 0 天 23 小时 0 分钟 0 秒。
我建议将 LocalDateTime 实例与 LocalDate 和 LocalTime 实例分开。之后，我们可以获得 Java 8 Period 和 Duration 实例。 Duration 实例按天数和全天时间值（
这是我计算 LocalDateTime 差异的方法：
private void getChronoUnitForSecondAfterFirst(LocalDateTime firstLocalDateTime, LocalDateTime secondLocalDateTime, long[] chronoUnits)
/*Separate LocaldateTime on LocalDate and LocalTime*/
LocalDate firstLocalDate = firstLocalDateTime.toLocalDate();
LocalTime firstLocalTime = firstLocalDateTime.toLocalTime();
LocalDate secondLocalDate = secondLocalDateTime.toLocalDate();
LocalTime secondLocalTime = secondLocalDateTime.toLocalTime();
/*Calculate the time difference*/
Duration duration = Duration.between(firstLocalDateTime, secondLocalDateTime);
long durationDays = duration.toDays();
Duration throughoutTheDayDuration = duration.minusDays(durationDays);
Logger.getLogger(PeriodDuration.class.getName()).log(Level.INFO,
"Duration is: " + duration + " this is " + durationDays
+ " days and " + throughoutTheDayDuration + " time.");
Period period = Period.between(firstLocalDate, secondLocalDate);
/*Correct the date difference*/
if (secondLocalTime.isBefore(firstLocalTime))
period = period.minusDays(1);
Logger.getLogger(PeriodDuration.class.getName()).log(Level.INFO,
"minus 1 day");
Logger.getLogger(PeriodDuration.class.getName()).log(Level.INFO,
"Period between " + firstLocalDateTime + " and "
+ secondLocalDateTime + " is: " + period + " and duration is: "
+ throughoutTheDayDuration
+ "\n-----------------------------------------------------------------");
/*Calculate chrono unit values and write it in array*/
chronoUnits[0] = period.getYears();
chronoUnits[1] = period.getMonths();
chronoUnits[2] = period.getDays();
chronoUnits[3] = throughoutTheDayDuration.toHours();
chronoUnits[4] = throughoutTheDayDuration.toMinutes() % 60;
chronoUnits[5] = throughoutTheDayDuration.getSeconds() % 60;
上述方法可用于计算任何本地日期和时间值的差异，例如：
public long[] getChronoUnits(String firstLocalDateTimeString, String secondLocalDateTimeString)
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime firstLocalDateTime = LocalDateTime.parse(firstLocalDateTimeString, formatter);
LocalDateTime secondLocalDateTime = LocalDateTime.parse(secondLocalDateTimeString, formatter);
long[] chronoUnits = new long[6];
if (secondLocalDateTime.isAfter(firstLocalDateTime))
getChronoUnitForSecondAfterFirst(firstLocalDateTime, secondLocalDateTime, chronoUnits);
else
getChronoUnitForSecondAfterFirst(secondLocalDateTime, firstLocalDateTime, chronoUnits);
return chronoUnits;
为上面的方法写一个单元测试很方便（都是PeriodDuration类的成员）。代码如下：
@RunWith(Parameterized.class)
public class PeriodDurationTest
private final String firstLocalDateTimeString;
private final String secondLocalDateTimeString;
private final long[] chronoUnits;
public PeriodDurationTest(String firstLocalDateTimeString, String secondLocalDateTimeString, long[] chronoUnits)
this.firstLocalDateTimeString = firstLocalDateTimeString;
this.secondLocalDateTimeString = secondLocalDateTimeString;
this.chronoUnits = chronoUnits;
@Parameters
public static Collection<Object[]> periodValues()
long[] chronoUnits0 = 0, 0, 0, 0, 0, 0;
long[] chronoUnits1 = 0, 0, 0, 1, 0, 0;
long[] chronoUnits2 = 0, 0, 0, 23, 0, 0;
long[] chronoUnits3 = 0, 0, 0, 1, 0, 0;
long[] chronoUnits4 = 0, 0, 0, 23, 0, 0;
long[] chronoUnits5 = 0, 0, 1, 23, 0, 0;
long[] chronoUnits6 = 29, 8, 24, 12, 0, 50;
long[] chronoUnits7 = 29, 8, 24, 12, 0, 50;
return Arrays.asList(new Object[][]
"2015-09-09 21:46:44", "2015-09-09 21:46:44", chronoUnits0,
"2015-09-09 21:46:44", "2015-09-09 22:46:44", chronoUnits1,
"2015-09-09 21:46:44", "2015-09-10 20:46:44", chronoUnits2,
"2015-09-09 21:46:44", "2015-09-09 20:46:44", chronoUnits3,
"2015-09-10 20:46:44", "2015-09-09 21:46:44", chronoUnits4,
"2015-09-11 20:46:44", "2015-09-09 21:46:44", chronoUnits5,
"1984-12-16 07:45:55", "2014-09-09 19:46:45", chronoUnits6,
"2014-09-09 19:46:45", "1984-12-16 07:45:55", chronoUnits6
);
@Test
public void testGetChronoUnits()
PeriodDuration instance = new PeriodDuration();
long[] expResult = this.chronoUnits;
long[] result = instance.getChronoUnits(this.firstLocalDateTimeString, this.secondLocalDateTimeString);
assertArrayEquals(expResult, result);
无论第一个 LocalDateTime 的值是否早于任何 LocalTime 值，所有测试都成功。
【讨论】：
我无法重现您的声明，即使用您上面的输入的 Thomas 代码会产生混合符号。我的输出是：“0 年 0 个月 0 天 23 小时 0 分钟 0 秒。”。而且我刚才已经测试过了。 感谢您的评论。我彻底测试了 Thomas 代码，确实，它工作正常！魔术是由 LocalDateTime 完成的，直到方法更正计时单位。如果第一个 DateTime 晚于第二个，则会出现 Thomas 代码中的负值。但这很容易纠正，例如，就像我在上面的代码中所做的那样。再次感谢。 嗯，Thomas 代码和我的库 Time4J 使用相同的算法计算持续时间可以产生负号，但仅适用于整个持续时间。这才是关键！该符号与整个持续时间相关，因此描述了开始是否晚于结束，并且与单个持续时间组件无关。混合标志在这里是不可能的，并且会阻止这种相对于结束的开始解释（反例是 Joda-Time-period 或java.time.Period，由于内部设计不同，用户可以强制/产生这种混合标志）。【参考方案4】：
@Thomas 在Groovy 中的版本使用列表中的所需单位，而不是对值进行硬编码。这种实现（可以很容易地移植到 Java - 我明确了函数声明）使 Thomas 方法更可重用。
def fromDateTime = LocalDateTime.of(1968, 6, 14, 0, 13, 0)
def toDateTime = LocalDateTime.now()
def listOfUnits = [
ChronoUnit.YEARS, ChronoUnit.MONTHS, ChronoUnit.DAYS,
ChronoUnit.HOURS, ChronoUnit.MINUTES, ChronoUnit.SECONDS,
ChronoUnit.MILLIS]
println calcDurationInTextualForm(listOfUnits, fromDateTime, toDateTime)
String calcDurationInTextualForm(List<ChronoUnit> listOfUnits, LocalDateTime ts, LocalDateTime to)
def result = []
listOfUnits.each chronoUnit ->
long amount = ts.until(to, chronoUnit)
ts = ts.plus(amount, chronoUnit)
if (amount)
result << "$amount $chronoUnit.toString()"
result.join(', ')
在撰写本文时，上面的代码返回47 Years, 8 Months, 9 Days, 22 Hours, 52 Minutes, 7 Seconds, 140 Millis。而且，对于@Gennady Kolomoets 输入，代码返回23 Hours。
当您提供单位列表时，它必须按单位的大小排序（最大的在前）：
def listOfUnits = [ChronoUnit.WEEKS, ChronoUnit.DAYS, ChronoUnit.HOURS]
// returns 2495 Weeks, 3 Days, 8 Hours
【讨论】：
【参考方案5】：这里有一个使用 Duration 和 TimeUnit 来获取 'hh:mm:ss' 格式的示例。
Duration dur = Duration.between(localDateTimeIni, localDateTimeEnd);
long millis = dur.toMillis();
String.format("%02d:%02d:%02d",
TimeUnit.MILLISECONDS.toHours(millis),
TimeUnit.MILLISECONDS.toMinutes(millis) -
TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
TimeUnit.MILLISECONDS.toSeconds(millis) -
TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));
【讨论】：
实际上可以这样做：String.format("%02d:%02d:%02d",dur.toHoursPart(), dur.toMinutesPart(), dur.toSecondsPart());。 part 方法为您提供了正确的数字来构建字符串。我认为它更具可读性。
我之前评论的旁注：part 方法仅适用于 JDK 9 及更高版本。【参考方案6】：
这是您问题的一个非常简单的答案。它有效。
import java.time.*;
import java.util.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
public class MyClass
public static void main(String args[])
DateTimeFormatter T = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
Scanner h = new Scanner(System.in);
System.out.print("Enter date of birth[dd/mm/yyyy hh:mm]: ");
String b = h.nextLine();
LocalDateTime bd = LocalDateTime.parse(b,T);
LocalDateTime cd = LocalDateTime.now();
long minutes = ChronoUnit.MINUTES.between(bd, cd);
long hours = ChronoUnit.HOURS.between(bd, cd);
System.out.print("Age is: "+hours+ " hours, or " +minutes+ " minutes old");
【讨论】：
我应该提到这是不准确的。试试这个。它说1分钟的差异。 LocalDateTime bd = LocalDateTime.of(2019, 11, 26, 15, 03, 55); LocalDateTime cd = LocalDateTime.of(2019, 11, 26, 15, 04, 45); 我昨晚输入了一个时间，得到了Age is: 0 years,0 months, 1 days, -10 hours, -48 minutes old。我认为这不是我们想要的。
@OleV.V.修复了这个问题【参考方案7】：
应该更简单！
Duration.between(startLocalDateTime, endLocalDateTime).toMillis();
您可以将毫单位转换为您喜欢的任何单位：
String.format("%d minutes %d seconds",
TimeUnit.MILLISECONDS.toMinutes(millis),
TimeUnit.MILLISECONDS.toSeconds(millis) -
TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));
【讨论】：
我相信这实际上是从 Java 8 开始的语义正确的解决方案。在该版本之前，JodaTime 也是如此。 这根本没有回答问题。 "两个 LocalDateTime 之间的差异多个单位"【参考方案8】：乔达时间
由于许多答案都需要 API 26 支持，而我的最低 API 为 23，因此我通过以下代码解决了它：
import org.joda.time.Days
LocalDate startDate = Something
LocalDate endDate = Something
// The difference would be exclusive of both dates,
// so in most of use cases we may need to increment it by 1
Days.daysBetween(startDate, endDate).days
【讨论】：
Joda-Time 项目处于维护模式，其创建者 Stephen Colebourne 继续创建 JSR 中定义的 java.time 类310. 大多数 java.time 功能在 ThreeTen-Backport 项目中被反向移植到 Java 6 和 7。在 ThreeTenABP 项目中进一步适用于早期的 android。【参考方案9】：TL;DR
// get the calendar period between the times (years, months & days)
Period period = Period.between(start.toLocalDate(), end.toLocalDate());
// make sure to get the floor of the number of days
period = period.minusDays(end.toLocalTime().compareTo(start.toLocalTime()) >= 0 ? 0 : 1);
// get the remainder as a duration (hours, minutes, etc.)
Duration duration = Duration.between(start, end);
// remove days, already counted in the period
duration = duration.minusDays(duration.toDaysPart());
然后使用方法period.getYears()、period.getMonths()、period.getDays()、duration.toHoursPart()、duration.toMinutesPart()、duration.toSecondsPart()。
Try it online!
扩展答案
我将回答最初的问题，即如何获得两个LocalDateTimes 之间的年、月、日、小时和分钟的时差，这样所有值的“总和”（见下文注释）不同的单位等于总的时间差，并且每个单位的值都小于下一个更大的单位——即minutes < 60、hours < 24 等等。
给定两个LocalDateTimesstart和end，例如
LocalDateTime start = LocalDateTime.of(2019, 11, 28, 17, 15);
LocalDateTime end = LocalDateTime.of(2020, 11, 30, 16, 44);
我们可以用Duration 表示两者之间的绝对时间跨度——也许使用Duration.between(start, end)。但是我们可以从Duration 中提取的最大单位是天（作为相当于 24 小时的时间单位）——请参阅下面的注释以获取解释。要使用更大的单位（月、年），我们可以用一对 (Period, Duration) 来表示 Duration，其中 Period 测量差异的精度为天，Duration 表示剩下的。
获取Period：
Period period = Period.between(start.toLocalDate(), end.toLocalDate());
我们在这里需要小心，因为Period 确实是一个日期 差异，而不是一个时间量，并且它的所有计算都基于日历日期（请参阅下面的部分）。例如，从 2000 年 1 月 1 日 23:59 到 2000 年 1 月 2 日 00:01，Period 会说有 1 天 的差异，因为这是两个日期之间的差异，即使时间增量小于 24 小时。因此，如果结束日期时间的时间早于开始日期时间的时间，我们需要从天数中减去 1，因为它不对应于完整的 24 小时跨度（相应的余数将是由我们的Duration记录）：
period = period.minusDays(end.toLocalTime().compareTo(start.toLocalTime()) >= 0 ? 0 : 1);
获取余数，作为Duration：
Duration duration = Duration.between(start, end);
由于我们的周期已经处理了精确到天的差异，我们只需要保留更小的单位（小时、分钟等）：
duration = duration.minusDays(duration.toDaysPart()); // essentially "duration (mod 1 day)"
现在我们可以简单地使用Period 和Duration 上定义的方法来提取各个单元：
System.out.printf(
"%d years, %d months, %d days, %d hours, %d minutes, %d seconds",
period.getYears(), period.getMonths(), period.getDays(),
duration.toHoursPart(), duration.toMinutesPart(), duration.toSecondsPart()
);
1 years, 0 months, 1 days, 23 hours, 29 minutes, 0 seconds
或者，使用默认格式：
System.out.println(period + " + " + duration);
P1Y1D + PT23H29M
年月日注释
请注意，在java.time 的概念中，“月”或“年”之类的周期“单位”并不代表固定的绝对时间值——它们取决于日期和日历，如下所示示例说明：
LocalDateTime
start1 = LocalDateTime.of(2020, 1, 1, 0, 0),
end1 = LocalDateTime.of(2021, 1, 1, 0, 0),
start2 = LocalDateTime.of(2021, 1, 1, 0, 0),
end2 = LocalDateTime.of(2022, 1, 1, 0, 0);
System.out.println(Period.between(start1.toLocalDate(), end1.toLocalDate()));
System.out.println(Duration.between(start1, end1).toDays());
System.out.println(Period.between(start2.toLocalDate(), end2.toLocalDate()));
System.out.println(Duration.between(start2, end2).toDays());
P1Y
366
P1Y
365
再举一个例子，从 2000 年 1 月 1 日 23:59 到 2000 年 1 月 2 日 00:01，Period 会说相差 1 天，因为这就是这两个日期，即使时间增量小于 24 小时。
【讨论】：
【参考方案10】：五年多后，我回答了我的问题。我认为负持续时间的问题可以通过简单的修正来解决：
LocalDateTime fromDateTime = LocalDateTime.of(2014, 9, 9, 7, 46, 45);
LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 46, 45);
Period period = Period.between(fromDateTime.toLocalDate(), toDateTime.toLocalDate());
Duration duration = Duration.between(fromDateTime.toLocalTime(), toDateTime.toLocalTime());
if (duration.isNegative())
period = period.minusDays(1);
duration = duration.plusDays(1);
long seconds = duration.getSeconds();
long hours = seconds / SECONDS_PER_HOUR;
long minutes = ((seconds % SECONDS_PER_HOUR) / SECONDS_PER_MINUTE);
long secs = (seconds % SECONDS_PER_MINUTE);
long time[] = hours, minutes, secs;
System.out.println(period.getYears() + " years "
+ period.getMonths() + " months "
+ period.getDays() + " days "
+ time[0] + " hours "
+ time[1] + " minutes "
+ time[2] + " seconds.");
注意：站点https://www.epochconverter.com/date-difference 现在可以正确计算时差。
感谢大家的讨论和建议。
【讨论】：
感谢您的回答。对于几个小时或更短的时间，您可以从Duration 的toHours、toMinutes 和toSeconds 方法中受益。从 Java 9 开始，更多来自 toMinutesPart() 和 toSecondsPart()。而且我看不出将小时、分钟和秒包装到一个数组中只是为了再次取出它们的意义。不过，通常是一个很好的答案。以上是关于Java 8：多个单位中两个 LocalDateTime 之间的差异的主要内容，如果未能解决你的问题，请参考以下文章