在 JDK7 中找到日期之间的真正差异
Finding the real difference between dates in JDK7
如何在 JDK7 中找到两个日期之间的差异，以便将差异加回去使两个日期相等？
我尝试使用 similar Whosebug question 中的解决方案，从另一个日期中减去一个日期的毫秒数，但这会导致日期之间的差异不正确。
在这个例子中，我尝试通过设置 a = (b-a) + a
使 a 等于 b
private void makeTwoDatesEqual(GregorianCalendar a, GregorianCalendar b, DatatypeFactory datatypeFactory) {
long b_minus_a = b.getTimeInMillis() - a.getTimeInMillis();
Duration delta = datatypeFactory.newDuration(b_minus_a);
delta.addTo(a);
}
但结果出人意料：
之前
a = "2015-08-29T00:00:00.000Z"
b = "2040-01-01T00:00:00.000Z"
delta = "P24Y4M5DT0H0M0.000S" // 2 days longer than it should be.
之后
a = "2040-01-03T00:00:00.000Z"
b = "2040-01-01T00:00:00.000Z"
delta = "P24Y4M5DT0H0M0.000S"
a.equals(b) = false
Joda-Time 有同样的问题：
private void makeTwoDatesEqual(GregorianCalendar a, GregorianCalendar b) {
DateTime date1 = new DateTime(a);
DateTime date2 = new DateTime(b);
Interval interval = new Interval(a.getTimeInMillis(), b.getTimeInMillis());
Period offsetPeriod = interval.toPeriod();
date1 = date1.plus(offsetPeriod);
date1.equals(date2); // false in my example
}
之前
date1 = "2015-08-29T00:00:00.000-05:00"
date2 = "2040-01-01T00:00:00.000-05:00"
offsetPeriod = "P24Y4M2DT23H"
date1.equals(date2) = false
之后
date1 = "2039-12-31T23:00:00.000-05:00"
date2 = "2040-01-01T00:00:00.000-05:00"
offsetPeriod = "P24Y4M2DT23H"
date1.equals(date2) = false
在询问之前，不需要考虑夏令时或闰年，因为在每个示例中，我都将时间间隔加回到与它派生的完全相同的时间段内。
ThreeTen 向后移植
使用称为 JSR-310 或 java.time 的现代 Java 日期和时间 API 有几种可能性。您可以将它与 Java 7 一起使用吗？当然！获取 ThreeTen Backport 并开始编码。
date-times
之间的区别
编辑： 如果您想将 a 和 b 视为时间点，换句话说，日期和一天中的时间，您可以使用适当小的时间单位来表示差异，或者 Duration class。两者的工作原理相同。由于 Instants 具有纳秒精度，计算纳秒级的差异将确保我们不会丢失任何精度：
Instant a = Instant.parse("2015-08-29T00:00:00.000Z");
Instant b = Instant.parse("2040-01-01T00:00:00.000Z");
long delta = ChronoUnit.NANOS.between(a, b);
a = a.plusNanos(delta);
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("delta = " + delta);
System.out.println("a.equals(b) = " + a.equals(b));
这会打印
a = 2040-01-01T00:00:00Z
b = 2040-01-01T00:00:00Z
delta = 768182400000000000
a.equals(b) = true
Duration class 用于以小时、分钟、秒和秒的分数为单位的持续时间。您可以使用它更长时间，但它不知道几周、几个月或几年。
Duration delta = Duration.between(a, b);
a = a.plus(delta);
否则和以前一样。这次输出是
a = 2040-01-01T00:00:00Z
b = 2040-01-01T00:00:00Z
delta = PT213384H
a.equals(b) = true
所以相差 213384 小时。只是因为在这种情况下分秒为0，所以不打印，否则会打印； Duration 也有纳秒精度。
日期之间的差异
更字面地理解您的标题，并注意到您的示例日期落在午夜 UTC。如果你不关心一天中的时间，只想计算天数、月数和年数，你可以使用 Period class 或者简单地计算天数。 Period class 用于天、月和年的时间段，精度为 1 天（这意味着，不能用于小时和更小的单位）。
LocalDate a = LocalDate.of(2015, Month.AUGUST, 29);
LocalDate b = LocalDate.of(2040, Month.JANUARY, 1);
Period delta = Period.between(a, b);
a = a.plus(delta);
打印和以前一样，但现在打印了
a = 2040-01-01
b = 2040-01-01
delta = P24Y4M3D
a.equals(b) = true
计算天数就像上面的纳秒一样，只是用天代替：
long delta = ChronoUnit.DAYS.between(a, b);
a = a.plusDays(delta);
这次输出包含：
delta = 8891
a.equals(b) = true
请注意，由于月份的长度不同，即使 24 年 4 个月 3 天似乎等于 8891 天，但实际情况往往并非如此。这在 @Meno Hochschild’s comment and Hugo’s answer 中有更详细的解释。所以在 Period 和天数之间的选择会有所不同，你应该根据你更确切的要求来选择。
合并期间和持续时间
Java 没有提供 class 年、月、日、小时、分钟和秒的时间段或持续时间，这有点有趣。如果需要，您可以使用 Period 实例表示年、月和日，然后使用 Duration 表示小时、分钟和秒。有点复杂。
我听说 ThreeTen-extra 项目包括一个将两者结合起来的 PeriodDuration class。我自己没有任何经验。
与一样，日期算法很奇怪，因为月份和年份可以有不同的长度。在我们的 ISO 日历中，一个月可以有 28、29、30 或 31 天，一年可以有 365 或 366 天。
因此，像 P24Y4M5D 这样的 Period（24 年 4 个月零 5 天）可以代表完全不同的天数，具体取决于 何时 你开始数吧。
例如，如果我从 2017-01-01T00:00Z 开始。如果我加上 24 年，我得到 2041-01-01，然后加上 4 个月，我得到 2041-05-01，然后加上 5 天，我得到 2041-05-06。总差相当于8891天。
但是如果我从 2016-01-01T00:00Z 开始并添加相同的时期（24 年 4 个月零 5 天）：添加 24 年我得到 2040-01-01，然后添加 4 个月我得到 2040-05-01，然后加上 5 天我得到 2040-05-06。但是如果我加上 8891 天，我会得到 2040-05-05.
那是因为月份和年份没有固定的长度，所以以天为单位的等效总数将始终取决于所涉及的日期（更不用说夏令时和闰秒效应，这也会改变总小时数、分、秒和毫秒）。
要不依赖于此，您必须使用以毫秒为单位的持续时间进行计算（而不是使用非固定长度的变量，例如年和月）。在 Joda-Time 中，您可以使用 org.joda.time.Duration class:
public void makeTwoDatesEqual(GregorianCalendar a, GregorianCalendar b) {
DateTime date1 = new DateTime(a);
DateTime date2 = new DateTime(b);
System.out.println("date1=" + date1);
System.out.println("date2=" + date2);
Duration duration = new Duration(date1, date2);
DateTime date3 = date1.plus(duration);
System.out.println("date3=" + date3);
System.out.println(date3.equals(date2));
}
假设a等价于2015-08-29T00:00:00Z，b等价于2040-01-01T00:00:00Z，这段代码会输出：
date1=2015-08-29T00:00:00.000Z
date2=2040-01-01T00:00:00.000Z
date3=2040-01-01T00:00:00.000Z
true
ThreeTen 向后移植
Joda-Time 处于维护模式，正在被新的 APIs 取代，所以我不建议用它开始一个新项目。即使在 joda's website 它说："Note that Joda-Time is considered to be a largely “finished” project. No major enhancements are planned. If using Java SE 8, please migrate to java.time (JSR-310).".
如果您不能（或不想）从 Joda-Time 迁移到新的 API，您可以忽略此部分。
如果您使用 Java 6 或 7，您可以使用 ThreeTen Backport, a great backport for Java 8's new date/time classes. And for Android, you'll also need the ThreeTenABP (more on how to use it ).
可以用org.threeten.bp.DateTimeUtilsclass将GregorianCalendar转换为org.threeten.bp.Instant，然后计算它们的差值，得到org.threeten.bp.Duration：
public void makeTwoDatesEqual(GregorianCalendar a, GregorianCalendar b) {
Instant instantA = DateTimeUtils.toInstant(a);
Instant instantB = DateTimeUtils.toInstant(b);
System.out.println(instantA);
System.out.println(instantB);
Duration duration = Duration.between(instantA, instantB);
Instant instantC = instantA.plus(duration);
System.out.println(instantC);
System.out.println(instantC.equals(instantB)); // true
}
假设a等价于2015-08-29T00:00:00Z，b等价于2040-01-01T00:00:00Z，这段代码会输出：
2015-08-29T00:00:00Z
2040-01-01T00:00:00Z
2040-01-01T00:00:00Z
true
如何在 JDK7 中找到两个日期之间的差异，以便将差异加回去使两个日期相等？
我尝试使用 similar Whosebug question 中的解决方案，从另一个日期中减去一个日期的毫秒数，但这会导致日期之间的差异不正确。
在这个例子中，我尝试通过设置 a = (b-a) + a
a 等于 b
private void makeTwoDatesEqual(GregorianCalendar a, GregorianCalendar b, DatatypeFactory datatypeFactory) {
long b_minus_a = b.getTimeInMillis() - a.getTimeInMillis();
Duration delta = datatypeFactory.newDuration(b_minus_a);
delta.addTo(a);
}
但结果出人意料：
之前
a = "2015-08-29T00:00:00.000Z"
b = "2040-01-01T00:00:00.000Z"
delta = "P24Y4M5DT0H0M0.000S" // 2 days longer than it should be.
之后
a = "2040-01-03T00:00:00.000Z"
b = "2040-01-01T00:00:00.000Z"
delta = "P24Y4M5DT0H0M0.000S"
a.equals(b) = false
Joda-Time 有同样的问题：
private void makeTwoDatesEqual(GregorianCalendar a, GregorianCalendar b) {
DateTime date1 = new DateTime(a);
DateTime date2 = new DateTime(b);
Interval interval = new Interval(a.getTimeInMillis(), b.getTimeInMillis());
Period offsetPeriod = interval.toPeriod();
date1 = date1.plus(offsetPeriod);
date1.equals(date2); // false in my example
}
之前
date1 = "2015-08-29T00:00:00.000-05:00"
date2 = "2040-01-01T00:00:00.000-05:00"
offsetPeriod = "P24Y4M2DT23H"
date1.equals(date2) = false
之后
date1 = "2039-12-31T23:00:00.000-05:00"
date2 = "2040-01-01T00:00:00.000-05:00"
offsetPeriod = "P24Y4M2DT23H"
date1.equals(date2) = false
在询问之前，不需要考虑夏令时或闰年，因为在每个示例中，我都将时间间隔加回到与它派生的完全相同的时间段内。
ThreeTen 向后移植
使用称为 JSR-310 或 java.time 的现代 Java 日期和时间 API 有几种可能性。您可以将它与 Java 7 一起使用吗？当然！获取 ThreeTen Backport 并开始编码。
date-times
之间的区别编辑： 如果您想将 a 和 b 视为时间点，换句话说，日期和一天中的时间，您可以使用适当小的时间单位来表示差异，或者 Duration class。两者的工作原理相同。由于 Instants 具有纳秒精度，计算纳秒级的差异将确保我们不会丢失任何精度：
Instant a = Instant.parse("2015-08-29T00:00:00.000Z");
Instant b = Instant.parse("2040-01-01T00:00:00.000Z");
long delta = ChronoUnit.NANOS.between(a, b);
a = a.plusNanos(delta);
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("delta = " + delta);
System.out.println("a.equals(b) = " + a.equals(b));
这会打印
a = 2040-01-01T00:00:00Z
b = 2040-01-01T00:00:00Z
delta = 768182400000000000
a.equals(b) = true
Duration class 用于以小时、分钟、秒和秒的分数为单位的持续时间。您可以使用它更长时间，但它不知道几周、几个月或几年。
Duration delta = Duration.between(a, b);
a = a.plus(delta);
否则和以前一样。这次输出是
a = 2040-01-01T00:00:00Z
b = 2040-01-01T00:00:00Z
delta = PT213384H
a.equals(b) = true
所以相差 213384 小时。只是因为在这种情况下分秒为0，所以不打印，否则会打印； Duration 也有纳秒精度。
日期之间的差异
更字面地理解您的标题，并注意到您的示例日期落在午夜 UTC。如果你不关心一天中的时间，只想计算天数、月数和年数，你可以使用 Period class 或者简单地计算天数。 Period class 用于天、月和年的时间段，精度为 1 天（这意味着，不能用于小时和更小的单位）。
LocalDate a = LocalDate.of(2015, Month.AUGUST, 29);
LocalDate b = LocalDate.of(2040, Month.JANUARY, 1);
Period delta = Period.between(a, b);
a = a.plus(delta);
打印和以前一样，但现在打印了
a = 2040-01-01
b = 2040-01-01
delta = P24Y4M3D
a.equals(b) = true
计算天数就像上面的纳秒一样，只是用天代替：
long delta = ChronoUnit.DAYS.between(a, b);
a = a.plusDays(delta);
这次输出包含：
delta = 8891
a.equals(b) = true
请注意，由于月份的长度不同，即使 24 年 4 个月 3 天似乎等于 8891 天，但实际情况往往并非如此。这在 @Meno Hochschild’s comment and Hugo’s answer 中有更详细的解释。所以在 Period 和天数之间的选择会有所不同，你应该根据你更确切的要求来选择。
合并期间和持续时间
Java 没有提供 class 年、月、日、小时、分钟和秒的时间段或持续时间，这有点有趣。如果需要，您可以使用 Period 实例表示年、月和日，然后使用 Duration 表示小时、分钟和秒。有点复杂。
我听说 ThreeTen-extra 项目包括一个将两者结合起来的 PeriodDuration class。我自己没有任何经验。
与
因此，像 P24Y4M5D 这样的 Period（24 年 4 个月零 5 天）可以代表完全不同的天数，具体取决于 何时 你开始数吧。
例如，如果我从 2017-01-01T00:00Z 开始。如果我加上 24 年，我得到 2041-01-01，然后加上 4 个月，我得到 2041-05-01，然后加上 5 天，我得到 2041-05-06。总差相当于8891天。
但是如果我从 2016-01-01T00:00Z 开始并添加相同的时期（24 年 4 个月零 5 天）：添加 24 年我得到 2040-01-01，然后添加 4 个月我得到 2040-05-01，然后加上 5 天我得到 2040-05-06。但是如果我加上 8891 天，我会得到 2040-05-05.
那是因为月份和年份没有固定的长度，所以以天为单位的等效总数将始终取决于所涉及的日期（更不用说夏令时和闰秒效应，这也会改变总小时数、分、秒和毫秒）。
要不依赖于此，您必须使用以毫秒为单位的持续时间进行计算（而不是使用非固定长度的变量，例如年和月）。在 Joda-Time 中，您可以使用 org.joda.time.Duration class:
public void makeTwoDatesEqual(GregorianCalendar a, GregorianCalendar b) {
DateTime date1 = new DateTime(a);
DateTime date2 = new DateTime(b);
System.out.println("date1=" + date1);
System.out.println("date2=" + date2);
Duration duration = new Duration(date1, date2);
DateTime date3 = date1.plus(duration);
System.out.println("date3=" + date3);
System.out.println(date3.equals(date2));
}
假设a等价于2015-08-29T00:00:00Z，b等价于2040-01-01T00:00:00Z，这段代码会输出：
date1=2015-08-29T00:00:00.000Z
date2=2040-01-01T00:00:00.000Z
date3=2040-01-01T00:00:00.000Z
true
ThreeTen 向后移植
Joda-Time 处于维护模式，正在被新的 APIs 取代，所以我不建议用它开始一个新项目。即使在 joda's website 它说："Note that Joda-Time is considered to be a largely “finished” project. No major enhancements are planned. If using Java SE 8, please migrate to java.time (JSR-310).".
如果您不能（或不想）从 Joda-Time 迁移到新的 API，您可以忽略此部分。
如果您使用 Java 6 或 7，您可以使用 ThreeTen Backport, a great backport for Java 8's new date/time classes. And for Android, you'll also need the ThreeTenABP (more on how to use it
可以用org.threeten.bp.DateTimeUtilsclass将GregorianCalendar转换为org.threeten.bp.Instant，然后计算它们的差值，得到org.threeten.bp.Duration：
public void makeTwoDatesEqual(GregorianCalendar a, GregorianCalendar b) {
Instant instantA = DateTimeUtils.toInstant(a);
Instant instantB = DateTimeUtils.toInstant(b);
System.out.println(instantA);
System.out.println(instantB);
Duration duration = Duration.between(instantA, instantB);
Instant instantC = instantA.plus(duration);
System.out.println(instantC);
System.out.println(instantC.equals(instantB)); // true
}
假设a等价于2015-08-29T00:00:00Z，b等价于2040-01-01T00:00:00Z，这段代码会输出：
2015-08-29T00:00:00Z
2040-01-01T00:00:00Z
2040-01-01T00:00:00Z
true