Java 8：两个LocalDateTime之间以多个单位表示的差异
问题描述 投票：250回答：9
我正在尝试计算两个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。因此该算法也需要处理负数。
请注意，问题不在于哪个站点给了我什么结果，我需要知道正确的算法，并且需要正确的结果。
9个回答
156
投票
投票
不幸的是，似乎也没有跨时间的周期类，因此您可能必须自己进行计算。
幸运的是，日期和时间类具有许多实用程序方法，可以在某种程度上简化此过程。这是一种计算差异的方法，尽管不一定最快：
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.
基本思想是：创建一个临时的开始日期并获得整年的结束时间。然后，根据年数调整该日期，以使开始日期小于结束日期。对每个时间单位按降序重复此操作。
最后免责声明：我没有考虑不同的时区（两个日期都应该在同一时区中），我也没有测试/检查夏令时或日历中的其他更改（例如萨摩亚的时区变化）会影响此计算。因此，请谨慎使用。
484
投票
投票
我发现最好的方法是使用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
41
投票
投票
这里是一个使用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)));
34
投票
投票
应该更简单！
Duration.between(startLocalDateTime, endLocalDateTime).toMillis();
5
投票
投票
并且Groovy中@Thomas的版本使用列表中的所需单位，而不是对值进行硬编码。这种实现（可以轻松地移植到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
4
投票
投票
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秒。
我建议在LocalDate和LocalTime实例上分开LocalDateTime实例。之后，我们可以获得Java 8 Period和Duration实例。持续时间实例按天数和全天时间值（<24h）分开，随后对周期值进行更正。当第二个LocalTime值在第一个LocalTime值之前时，有必要缩短一天的时间。
这是我计算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值之前或之后，所有测试均成功。
4
投票
投票
这里是您问题的非常简单的答案。有效。
import java.time.*;
import java.util.*;
import java.time.format.DateTimeFormatter;
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();
int hr = cd.getHour() - bd.getHour();
int mn = cd.getMinute() - bd.getMinute();
Period time = Period.between(bd.toLocalDate(),cd.toLocalDate());
System.out.print("Age is: "+time.getYears()+ " years,"+time.getMonths()+ " months, " +time.getDays()+ " days, "+hr+ " hours, " +mn+ " minutes old");
}
}
3
投票
投票
TL; DR
Duration duration = Duration.between(start, end);
duration = duration.minusDays(duration.toDaysPart()); // essentially "duration (mod 1 day)"
Period period = Period.between(start.toLocalDate(), end.toLocalDate());
然后使用方法period.getYears()，period.getMonths()，period.getDays()，duration.toHoursPart()，duration.toMinutesPart()，duration.toSecondsPart()。
扩展答案
我将回答原始问题，即如何获取年，月，日，小时和分钟中两个LocalDateTimes之间的时差，以使该值的所有值的“总和”（请参见下面的注释）不同的单位等于总的时间差，因此每个单位中的值小于下一个较大的单位，即minutes < 60，hours < 24，依此类推。
给出两个LocalDateTimes start和end，例如
LocalDateTime start = LocalDateTime.of(2019, 11, 29, 17, 15);
LocalDateTime end = LocalDateTime.of(2020, 11, 30, 18, 44);
我们可以用Duration表示两者之间的绝对时间跨度-也许使用Duration.between(start, end)。但是，我们可以从Duration中提取的最大单位是天（相当于24小时的时间单位），请参阅以下说明以获取解释。要使用较大的单位（月，年），我们可以用一对[Duration，Period）表示此Duration，其中Period可以测量直到天精度的差，而Duration代表其余：
Duration duration = Duration.between(start, end);
duration = duration.minusDays(duration.toDaysPart()); // essentially "duration (mod 1 day)"
Period period = Period.between(start.toLocalDate(), end.toLocalDate());
现在我们可以简单地使用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, 1 hours, 29 minutes, 0 seconds
或使用默认格式：
System.out.println(period + " + " + duration);
P1Y1D + PT1H29M
注意年月日
[请注意，在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
1
投票
投票
Joda-Time
由于许多答案都需要API 26支持，而我的min 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
最新问题
- 平衡二叉搜索树和二叉搜索树有什么区别？
- 如何在TWebScrollBox中设置滚动条位置？
- Apple Metal 中如何描述紧密堆积的顶点数据？
- 循环迭代在第二次迭代时失败
- rusty_v8 TryCatch 未捕获堆限制
- 检测RTP流中使用的编解码器（对于动态PT）
- 变量“未定义”错误，即使已定义
- rebase 后进行 Git 推送
- Postgres 自增主键
- Delphi 中 DataModule 的访问冲突
- 正则表达式在 TMS WEB Core 中如何工作？
- 检索 ValueError：int() 的文字无效
- React/Mobx 无法覆盖 Props 设置的默认值
- 条件语句 `if ( ( i != '7' ) && ( j != '8' ) && ( k != '9' ) )` 会产生不稳定的结果
- Flutter无法滚动到列表View底部
- 语法错误：无法在模块 { AXIOS } 之外使用 import 语句
- 适用于Windows Vista 32位系统的Java JDK
- 即使上下文隔离关闭，如何使 contextBridge 工作
- 无法在 php 中包含文件或目录（警告：require_once(../layout/)：无法打开流）
- 版本控制存储桶的 Amazon S3 一致性
© www.soinside.com 2019 - 2024. All rights reserved.