Java 8:两个LocalDateTime之间以多个单位表示的差异


266

我正在尝试计算两者之间的差异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:5509/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。因此该算法也需要处理负数。

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


只是一个猜测,但可能需要Period.between()四舍五入吗?
托马斯

3
我只是再次看了看代码,看来网站是错误的(尝试自己计算)。如果省略日期,即年,月和日之间的差异,则将获得开始时间7:45:55和结束时间19:46:45(或7:46:45PM)。因此,这两次之间的时差是12小时0分50秒,而永远不会是 23小时34分12秒。因此,您的计算实际至少在时间部分看来是正确的。
托马斯

1
该网站上有趣的现象:开始日期增加了10年,时差从23变为8-肯定是错误的迹象。
托马斯

8
请注意,由于LocalDateTime没有时区,因此可能没有唯一答案。即使您假设开始时区和结束时区都相同,在某些时区中,例如2014-09-09的日期仍将是夏时制或夏令时,而在其他时区则不会。这可能会使事情推迟一个小时。因此,除非解决此问题,否则计算秒数的差是没有意义的。
Stuart Marks

2
您是否了解使用LocalDateTime该类会产生不切实际的结果,因为该类故意缺乏时区或UTC偏移的概念?对于实际值,请通过ZoneId使用分配时区ZonedDateTime
罗勒·布尔克

Answers:


163

不幸的是,似乎还没有一个跨时间的周期类,因此您可能必须自己进行计算。

幸运的是,日期和时间类具有许多实用程序方法,可以在某种程度上简化此过程。这是一种计算差异的方法,尽管不一定最快:

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.

基本思想是:创建一个临时的开始日期并获得整年的结束时间。然后,根据年数调整该日期,以使开始日期少于结束日期。对每个时间单位以降序重复该操作。

最后免责声明:我没有考虑不同的时区(两个日期都应该在同一时区中),也没有测试/检查夏令时或日历中的其他更改(例如萨摩亚中的时区更改)影响此计算。因此,请谨慎使用。


1
您有相同的基本想法,因此我赞成,但是请尝试使用相同的输入,否则不同的结果会造成混淆。
Meno Hochschild 2014年

@MenoHochschild 相同的输入,只是从OP出现负时间问题的更新中获取的。;)
Thomas

1
好的算法,但类型错误(请参阅Thomas免责声明)。在进行计算之前,您应该使用默认时区(或所需的任何时区)将LocalDateTime变量转换为ZonedDateTime:ZonedDateTime fromZonedDateTime = fromDateTime.atZone(ZoneId.systemDefault());
特里斯坦2015年

2
@Thomas您的示例也使用Java 8-问题被标记为Java-8。实际上,您的示例甚至使用了ChronoUnit:),但“手动”完成了工作。
尤金·别列索夫斯基

3
@EugeneBeresovsky哦,是的,你是对的。完全错过了;)-除此之外,您还必须从间隔中减去较大的单位,因为例如long minutes = ChronoUnit.MINUTES.between(fromDate, toDate);,对于至少1小时的任何间隔,它将返回大于59的数字-这不是OP想要的。考虑到这一点,您将无法仅拨打6次电话ChronoUnit#between()并完成通话。
汤玛斯(Thomas)

502

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


8
我没有看到真正的进步。与接受的Thomas答案相比,您只需将替换tempDateTime.until( toDateTime, ChronoUnit.YEARS)ChronoUnit.YEARS.between(fromDate, toDate)。但是,tempDateTime.plusYears( years )答案等重要的附加行等都完全丢失了,因此对OP没有帮助。完整的算法很重要!
Meno Hochschild 2015年

9
我更喜欢它,因为它更简洁,可读性更好。这是找出两个日期之间差异的最佳方法。
Somaiah Kumbera '16

7
@SomaiahKumbera不,您完全错过了关键点。OP不希望持续时间仅以一个单位为单位而是想要多个单位,因此该答案根本不是真正的答案。根本没有解决OP的担忧。请再次阅读此问题。(许多支持者似乎误解了这个问题)。
Meno Hochschild

125
@MenoHochschild,我认为您实际上是缺少关键点的人。OP一年多以前就得到了答案。正在查看此问题的36,000人并不关心OP的特定问题。他们是由google领导的,我的回答为他们提供了他们所寻找的东西-一种干净而简单的解决方案,用于获取两个日期之间的差额。
satnam

10
我需要两个日期时间之间的秒差,并开始实施自己的解决方案。不久,这似乎很复杂,我选择了Google。satnam答案可能无法回答OP问题,但可以肯定的是,这对我有很大帮助,我敢打赌像我这样的许多其他人。
朱利安

43

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

2
它实际上是有可能做到这一点是这样的:String.format("%02d:%02d:%02d",dur.toHoursPart(), dur.toMinutesPart(), dur.toSecondsPart());。部分方法为您提供正确的数字以构建字符串。我认为它更具可读性。
丹蒂

我之前的评论的旁注:part方法仅在JDK 9及更高版本中可用。
丹妮

40

它应该更简单!

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

1
我相信这实际上是从Java 8开始在语义上正确的解决方案。在该版本之前,JodaTime会这样做。
Vrakfall

9

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 < 60hours < 24等等)。

给定两个LocalDateTimes startend,例如

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

我们可以用表示两者之间的绝对时间跨度Duration使用-perhaps Duration.between(start, end)。但是,我们可以从a中提取的最大单位Duration是天(相当于24h的时间单位),请参阅以下注释以获取说明。要使用更大的单位(月,年),我们可以代表这个Duration有一对(PeriodDuration),其中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

5

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值之前以及对于任何LocalTime值,所有测试均成功。


我无法重述您的陈述,即使用上述输入的Thomas代码会产生混合符号。我的输出是:“ 0年0个月0天23小时0分钟0秒。”。我刚刚进行了测试。
Meno Hochschild

谢谢你的意见。我彻底测试了Thomas代码,的确,它可以正常工作!直到完成方法校正计时单位,魔术才由LocalDateTime完成。如果第一个DateTime晚于第二个DateTime,则会在Thomas代码中显示负值。但这可以很容易地纠正,例如,就像我在上面的代码中所做的那样。再次感谢。
纳季·科洛莫耶斯(Nennady Kolomoets)2015年

好吧,Thomas代码和我的库Time4J使用相同的算法来计算持续时间会产生负号,但只会在整个持续时间内产生。这才是关键!该符号与整个持续时间相关,因此描述了开始时间是否晚于结束时间,并且从未与单个持续时间成分相关。混合符号在这里是不可能的,并且会阻止对开始相对于结束的解释(反例是Joda-Time-period,或者java.time.Period由于内部设计不同,用户可以强制/产生这种混合符号)。
Meno Hochschild 2015年

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

这是您问题的非常简单的答案。有用。

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
我应该提到这是不准确的。试试这个。表示相差1分钟。LocalDateTime bd = LocalDateTime.of(2019,11,26,15,03,55); cd = LocalDateTime.of(2019,11,26,15,04,45);
Mark Amabile

我昨晚进入某个时间并得到了Age is: 0 years,0 months, 1 days, -10 hours, -48 minutes old。我认为这不是期望的。
Ole VV

@ OleV.V。解决了该问题
SavedBeau

1

乔达时代

由于许多答案都需要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

1
乔达时间项目处于维护模式,它的创始人斯蒂芬Colebourne对在经历制作了java.time在JSR 310中定义的类大部分java.time功能在后移植到Java 6和7 ThreeTen-反向移植项目。在ThreeTenABP项目中进一步适用于早期的Android 。
罗勒·布尔克

1

五年多后,我回答了我的问题。我认为,持续时间为负数的问题可以通过简单的更正来解决:

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现在可以正确计算时差。

谢谢大家的讨论和建议。


感谢你的回答。对于时间和更小的,你可以从受益toHourstoMinutestoSeconds方法Duration。由于Java 9甚至更多来自toMinutesPart()toSecondsPart()。而且我看不到将小时,分钟和秒包装到数组中以仅将它们再次取出的意义。通常,这是一个很好的答案。
Ole VV

五年多后,我回答了我的问题。该问题是通过一个名称,标题和位置不同的帐户发布的,似乎不太相似吗?不知道它有什么重要性,只是想知道。
Ole VV

“五年后,我回答了我的问题”我想我是OP :)
Tapas Bose
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.