Java 8:计算两个LocalDateTime之间的差异

Question

我试图计算两者之间的差异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.我已经从这个网站查看了我的结果(有值12/16/1984 07:45:55和09/09/2014 19:46:45).以下屏幕截图显示了输出:

我很确定月份值之后的字段从我的代码中出错了.任何建议都会非常有帮助.

更新

我已经从另一个网站测试了我的结果,我得到的结果是不同的.这是:计算两个日期之间的持续时间(结果: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.

从这个链接应该是29 years 8 months 24 days 22 hours, 54 minutes and 50 seconds.因此算法也需要处理负数.

注意问题不在于哪个网站给了我什么结果,我需要知道正确的算法并且需要有正确的结果.

Answer 1

我发现最好的方法是使用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

Answer 2

不幸的是,似乎没有一个时间段也跨越时间,所以你可能需要自己进行计算.

幸运的是,日期和时间类有很多实用方法可以在某种程度上简化它.这是一种计算差异的方法,虽然不一定是最快的:

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.

基本思路是这样的:创建一个临时的开始日期,并将整年打印到最后.然后按年数调整该日期,以便开始日期比结束时少一年.对每个时间单位按降序重复该操作.

最后一个免责声明:我没有考虑不同的时区(两个日期应该在同一时区),我也没有测试/检查日历中的夏令时或其他变化(如萨摩亚的时区变化)影响这个计算.所以要小心使用.

Answer 3

这里有一个使用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)));

Answer 4

它应该更简单!

Duration.between(startLocalDateTime, endLocalDateTime).toMillis();

Answer 5

TL; 博士

// 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()。

在线试试吧！

扩展答案

我将回答最初的问题，即如何获得两个LocalDateTimes以年、月、日、小时和分钟为单位的时差，以便不同单位的所有值的“总和”（见下面的注释）等于总和时间差异，使得每个单元中的值小于下一个更大的单元——即minutes < 60，hours < 24，等等。

给定两个LocalDateTimes start和end，例如

LocalDateTime start = LocalDateTime.of(2019, 11, 28, 17, 15);
LocalDateTime end = LocalDateTime.of(2020, 11, 30, 16, 44);

我们可以用 表示两者之间的绝对时间跨度——Duration也许使用Duration.between(start, end)。但是我们可以从 a 中提取的最大单位Duration是天（作为相当于 24 小时的时间单位）——请参阅下面的注释以获取解释。要使用更大的单位（月、年），我们可以Duration用一对 ( Period, Duration)表示它，其中Period测量差异达到天数的精度，而Duration表示余数。

要获得Period：

Period period = Period.between(start.toLocalDate(), end.toLocalDate());

在这里我们需要小心，因为 aPeriod实际上是一个日期差异，而不是时间量，并且它的所有计算都是基于日历日期（参见下面的部分）。例如，从 2000 年 1 月 1 日 23:59 到 2000 年 1 月 2 日 00:01，aPeriod会说有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

注意年月日

请注意，在 injava.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，aPeriod会说有1 天的差异，因为这是两个日期之间的差异，即使时间增量小于 24 小时.

Answer 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");
}
}

Answer 7

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 实例。Duration 实例按天数和全天时间值（< 24 小时）分开，随后对周期值进行更正。当第二个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 值之前和之前，所有测试都成功。

Answer 8

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