计算两个 Java 日期实例之间的差异

发布于 2024-09-14 11:19:19 字数 260 浏览 7 评论 0原文

我在 Scala 中使用 Java 的 java.util.Date 类，并且想要比较 Date 对象和当前时间。我知道我可以使用 getTime() 来计算增量：

(new java.util.Date()).getTime() - oldDate.getTime()

但是，这只会给我留下一个代表毫秒的 long 。有没有更简单、更好的方法来获取时间增量？

原文

I'm using Java's java.util.Date class in Scala and want to compare a Date object and the current time. I know I can calculate the delta by using getTime():

(new java.util.Date()).getTime() - oldDate.getTime()

However, this just leaves me with a long representing milliseconds. Is there any simpler, nicer way to get a time delta?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

于我来说 2024-09-21 11:19:19

简单的 diff （不带 lib）

/**
 * Get a diff between two dates
 * @param date1 the oldest date
 * @param date2 the newest date
 * @param timeUnit the unit in which you want the diff
 * @return the diff value, in the provided unit
 */
public static long getDateDiff(Date date1, Date date2, TimeUnit timeUnit) {
    long diffInMillies = date2.getTime() - date1.getTime();
    return timeUnit.convert(diffInMillies,TimeUnit.MILLISECONDS);
}

然后你可以调用：

getDateDiff(date1,date2,TimeUnit.MINUTES);

来获取 2 个日期的差异（以分钟为单位）。

TimeUnit 是 java.util.concurrent.TimeUnit，一个从纳秒到天的标准 Java 枚举。

人类可读的差异（不带 lib）

public static Map<TimeUnit,Long> computeDiff(Date date1, Date date2) {

    long diffInMillies = date2.getTime() - date1.getTime();

    //create the list
    List<TimeUnit> units = new ArrayList<TimeUnit>(EnumSet.allOf(TimeUnit.class));
    Collections.reverse(units);

    //create the result map of TimeUnit and difference
    Map<TimeUnit,Long> result = new LinkedHashMap<TimeUnit,Long>();
    long milliesRest = diffInMillies;

    for ( TimeUnit unit : units ) {
        
        //calculate difference in millisecond 
        long diff = unit.convert(milliesRest,TimeUnit.MILLISECONDS);
        long diffInMilliesForUnit = unit.toMillis(diff);
        milliesRest = milliesRest - diffInMilliesForUnit;

        //put the result in the map
        result.put(unit,diff);
    }

    return result;
}

http://ideone.com/5dXeu6

输出类似于 Map :{DAYS=1, HOURS=3, MINUTES=46, SECONDS=40, MILLISECONDS=0, MICROSECONDS=0, NANOSECONDS=0}，单位已排序。

您只需将该映射转换为用户友好的字符串即可。

警告

上面的代码片段计算两个时刻之间的简单差异。它可能会在夏令时切换期间导致问题，如这篇文章中所述。这意味着，如果您计算没有时间的日期之间的差异，则可能会缺少日期/小时。

在我看来，日期差异有点主观，尤其是在几天内。您可以：

计算 24 小时经过的时间：天+1 - 天=1 天=24 小时
计算经过的时间数，考虑夏令时：day+1 - day = 1 = 24h（但使用午夜时间和夏令时）节省时间可能是 0 天 23 小时）
计算日切换的数量，这意味着 day+1 1pm - day 11am = 1 天，即使经过的时间只有 2 小时（如果有夏令时则为 1 小时:p）

我的答案是如果您对天数的日期差异的定义与第一种情况匹配，则有效使用

JodaTime

如果您使用 JodaTime，您可以通过以下方式获取 2 个瞬间（米莉支持 ReadableInstant）日期的差异：

Interval interval = new Interval(oldInstant, new Instant());

但您也可以获取本地日期/时间的差异：

// returns 4 because of the leap year of 366 days
new Period(LocalDate.now(), LocalDate.now().plusDays(365*5), PeriodType.years()).getYears() 

// this time it returns 5
new Period(LocalDate.now(), LocalDate.now().plusDays(365*5+1), PeriodType.years()).getYears() 

// And you can also use these static methods
Years.yearsBetween(LocalDate.now(), LocalDate.now().plusDays(365*5)).getYears()

Simple diff (without lib)

/**
 * Get a diff between two dates
 * @param date1 the oldest date
 * @param date2 the newest date
 * @param timeUnit the unit in which you want the diff
 * @return the diff value, in the provided unit
 */
public static long getDateDiff(Date date1, Date date2, TimeUnit timeUnit) {
    long diffInMillies = date2.getTime() - date1.getTime();
    return timeUnit.convert(diffInMillies,TimeUnit.MILLISECONDS);
}

And then you can call:

getDateDiff(date1,date2,TimeUnit.MINUTES);

to get the diff of the 2 dates in minutes unit.

TimeUnit is java.util.concurrent.TimeUnit, a standard Java enum going from nanos to days.

Human readable diff (without lib)

public static Map<TimeUnit,Long> computeDiff(Date date1, Date date2) {

    long diffInMillies = date2.getTime() - date1.getTime();

    //create the list
    List<TimeUnit> units = new ArrayList<TimeUnit>(EnumSet.allOf(TimeUnit.class));
    Collections.reverse(units);

    //create the result map of TimeUnit and difference
    Map<TimeUnit,Long> result = new LinkedHashMap<TimeUnit,Long>();
    long milliesRest = diffInMillies;

    for ( TimeUnit unit : units ) {
        
        //calculate difference in millisecond 
        long diff = unit.convert(milliesRest,TimeUnit.MILLISECONDS);
        long diffInMilliesForUnit = unit.toMillis(diff);
        milliesRest = milliesRest - diffInMilliesForUnit;

        //put the result in the map
        result.put(unit,diff);
    }

    return result;
}

http://ideone.com/5dXeu6

The output is something like Map:{DAYS=1, HOURS=3, MINUTES=46, SECONDS=40, MILLISECONDS=0, MICROSECONDS=0, NANOSECONDS=0}, with the units ordered.

You just have to convert that map to a user-friendly string.

Warning

The above code snippets compute a simple diff between 2 instants. It can cause problems during a daylight saving switch, like explained in this post. This means if you compute the diff between dates with no time you may have a missing day/hour.

In my opinion the date diff is kind of subjective, especially on days. You may:

count the number of 24h elapsed time: day+1 - day = 1 day = 24h
count the number of elapsed time, taking care of daylight savings: day+1 - day = 1 = 24h (but using midnight time and daylight savings it could be 0 day and 23h)
count the number of day switches, which means day+1 1pm - day 11am = 1 day, even if the elapsed time is just 2h (or 1h if there is a daylight saving :p)

My answer is valid if your definition of date diff on days match the 1st case

With JodaTime

If you are using JodaTime you can get the diff for 2 instants (millies backed ReadableInstant) dates with:

Interval interval = new Interval(oldInstant, new Instant());

But you can also get the diff for Local dates/times:

// returns 4 because of the leap year of 366 days
new Period(LocalDate.now(), LocalDate.now().plusDays(365*5), PeriodType.years()).getYears() 

// this time it returns 5
new Period(LocalDate.now(), LocalDate.now().plusDays(365*5+1), PeriodType.years()).getYears() 

// And you can also use these static methods
Years.yearsBetween(LocalDate.now(), LocalDate.now().plusDays(365*5)).getYears()

计算两个 Java 日期实例之间的差异

如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

评论（30）

简单的 diff （不带 lib）

人类可读的差异（不带 lib）

警告

JodaTime

Simple diff (without lib)

Human readable diff (without lib)

Warning

With JodaTime

tl;dr

ISO 8601 格式： PnYnMnDTnHnMnS

java.time

a

时间跨度

ChronoUnit

关于 java.time

Joda-Time

tl;dr

ISO 8601 Format: PnYnMnDTnHnMnS

java.time

Moment

Span of time

ChronoUnit

About java.time

Joda-Time

关于作者

相关话题

热门标签

推荐作者

留蓝

18790681156

zach7772

Wini

ayeshaaroy

初雪

友情链接

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

ISO 8601 格式： `PnYnMnDTnHnMnS`

`ChronoUnit`

ISO 8601 Format: `PnYnMnDTnHnMnS`

`ChronoUnit`