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

StackOverflow https://stackoverflow.com/questions/1555262

题

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

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

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

有帮助吗？

解决方案

JDK Date 不幸的是，API 被严重破坏了。我建议使用 乔达时间库.

Joda Time有时间概念 间隔:

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

编辑：顺便说一句，Joda 有两个概念： Interval 用于表示两个时刻之间的时间间隔（表示上午 8 点到上午 10 点之间的时间），以及 Duration 表示没有实际时间界限的时间长度（例如代表两个小时！）

如果你只关心时间比较，大多数 Date 实现（包括 JDK 之一）实现 Comparable 界面允许您使用 Comparable.compareTo()

其他提示

简单差异（无库）

/**
 * 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);

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

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

人类可读的差异（没有库）

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 小时

  • 计算经过的时间，考虑夏令时：天+1 - 天 = 1 = 24 小时（但使用午夜时间和夏令时，可能是 0 天和 23 小时）

  • 数数 day switches, ，这意味着 day+1 1pm - day 11am = 1 天，即使经过的时间只有 2 小时（如果有夏令时则​​为 1 小时:p）

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

与乔达时间

如果您使用 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()

int diffInDays = (int)( (newerDate.getTime() - olderDate.getTime()) 
                 / (1000 * 60 * 60 * 24) )

请注意，这可与UTC日期，这样的差异可能是一天，如果你看看当地的日期。并得到它与当地的日期正常工作，需要一个完全不同的方法，由于夏令时。

您需要更清楚地定义您的问题。你 可以 只需取两者之间的毫秒数 Date 对象并除以 24 小时内的毫秒数，例如......但：

  • 这不会考虑时区 - Date 始终采用 UTC
  • 这不会考虑夏令时（例如，有些日子可能只有 23 小时长）
  • 即使在UTC内，8月16日晚上11点到8月18日凌晨2点也有多少天？才27个小时，难道就是一天吗？或者应该是三天，因为它涵盖了三个日期？

使用 java.time Java 8+ 内置框架：

ZonedDateTime now = ZonedDateTime.now();
ZonedDateTime oldDate = now.minusDays(1).minusMinutes(10);
Duration duration = Duration.between(oldDate, now);
System.out.println("ISO-8601: " + duration);
System.out.println("Minutes: " + duration.toMinutes());

输出：

ISO-8601：PT24H10M

分钟：1450

欲了解更多信息，请参阅 甲骨文教程 和 ISO 8601 标准。

太长了；博士

转换你的过时的 java.util.Date 反对更换他们， java.time.Instant. 。然后将经过的时间计算为 Duration.

Duration d = 
    Duration.between(                   // Calculate the span of time between two moments as a number of hours, minutes, and seconds.
        myJavaUtilDate.toInstant() ,    // Convert legacy class to modern class by calling new method added to the old class.
        Instant.now()                   // Capture the current moment in UTC. About two and a half hours later in this example.
    )
;

d.toString():PT2H34M56S

d.toMinutes():154

d.toMinutesPart():34

ISO 8601 格式： PnYnMnDTnHnMnS

合理的标准 ISO 8601 将时间跨度定义为年、月、日、小时等的简明文本表示。标准称这样的跨度为 期间. 。格式为 PnYnMnDTnHnMnS 哪里的 P 意思是“时期”， T 将日期部分与时间部分分开，中间是数字，后跟字母。

例子：

  • P3Y6M4DT12H30M5S
    三年六个月零四天十二小时三十分钟零五秒
  • PT4H30M
    四个半小时

java.time

这 java.time Java 8 中内置的框架，后来取代了麻烦的旧框架 java.util.Date/java.util.Calendar 类。新课程的灵感来自于非常成功的 乔达时间 框架，旨在作为其继承者，概念相似但重新架构。被定义为 JSR 310. 。扩展为 三十额外 项目。请参阅 教程.

片刻

这 Instant 类代表时间线上的一个时刻 世界标准时间 分辨率为 纳秒 （最多九 (9) 位小数）。 

Instant instant = Instant.now() ;  // Capture current moment in UTC.

最好避免遗留类，例如 Date/Calendar. 。但是，如果您必须与尚未更新的旧代码进行互操作 java.time, ，来回转换。调用添加到旧类中的新转换方法。对于从 java.util.Date 到一个 Instant, ， 称呼 Date::toInstant. 

Instant instant = myJavaUtilDate.toInstant() ;  // Convert from legacy `java.util.Date` class to modern `java.time.Instant` class.

时间跨度

java.time 类将这种将时间跨度表示为年、月、日、小时、分钟、秒的想法分成两半：

这是一个例子。

ZoneId zoneId = ZoneId.of ( "America/Montreal" );
ZonedDateTime now = ZonedDateTime.now ( zoneId );
ZonedDateTime future = now.plusMinutes ( 63 );
Duration duration = Duration.between ( now , future );

转储到控制台。

两个都 Period 和 Duration 使用 ISO 8601 生成其值的字符串表示的标准。

System.out.println ( "now: " + now + " to future: " + now + " = " + duration );

现在：2015-11-26T00:46:48.016-05:00[美国/蒙特利尔] 至未来：2015-11-26T00:46:48.016-05:00[美国/蒙特利尔] = PT1H3M

Java 9 添加了方法 Duration 获取天部分、小时部分、分钟部分和秒部分。

您可以获得整个 Duration 内的总天数或小时数或分钟数或秒数或毫秒数或纳秒数。

long totalHours = duration.toHours();

在 Java 9 中 Duration 类获得新方法 用于返回天、小时、分钟、秒、毫秒/纳秒的各个部分。致电 to…Part 方法： toDaysPart(), toHoursPart(), ， 等等。

ChronoUnit

如果您只关心更简单的较大时间粒度，例如“经过的天数”，请使用 ChronoUnit 枚举。

long daysElapsed = ChronoUnit.DAYS.between( earlier , later );

另一个例子。

Instant now = Instant.now();
Instant later = now.plus( Duration.ofHours( 2 ) );
…
long minutesElapsed = ChronoUnit.MINUTES.between( now , later );

120

关于 java.time

这 java.time 框架内置于 Java 8 及更高版本中。这些课程取代了麻烦的旧课程 遗产 日期时间类，例如 java.util.Date, Calendar, & SimpleDateFormat.

这 乔达时间 项目，现在在 维护模式, ，建议迁移到 java.time。

要了解更多信息，请参阅 甲骨文教程. 。并在 Stack Overflow 上搜索许多示例和解释。规格为 JSR 310.

从哪里获取 java.time 类？

这 三十额外 项目通过附加类扩展了 java.time。该项目是 java.time 未来可能添加的内容的试验场。您可能会在这里找到一些有用的类，例如 Interval, YearWeek, YearQuarter, ， 和 更多的.

乔达时间

更新：这 乔达时间 项目现已在 维护模式, ，团队建议迁移到 java.time 类。我将这一部分原封不动地留作历史。

Joda-Time 库使用 ISO 8601 作为默认值。它是 Period 类解析并生成这些 PnYnMnDTnHnMnS 字符串。

DateTime now = DateTime.now(); // Caveat: Ignoring the important issue of time zones.
Period period = new Period( now, now.plusHours( 4 ).plusMinutes( 30));
System.out.println( "period: " + period );

渲染：

period: PT4H30M

Days d = Days.daysBetween(startDate, endDate);
int days = d.getDays();

https://www.joda.org/joda-time/faq html的＃DATEDIFF

一个稍微简单的替代：

System.currentTimeMillis() - oldDate.getTime()

至于“更好”：好了，你到底需要什么？与表示持续时间为若干小时和天等的问题是，它可能会导致不准确和错误的预期由于日期的复杂性（例如天能有由于日光节约时间23或25小时）。

使用毫秒的方法可能会导致在某些地区的问题。

让我们，例如，这两个日期2007年3月24日2007年3月25日和之间的差应当为1天;

不过，使用毫秒的路线，你会得0天，如果你在英国运行此！ 

/** Manual Method - YIELDS INCORRECT RESULTS - DO NOT USE**/  
/* This method is used to find the no of days between the given dates */  
public long calculateDays(Date dateEarly, Date dateLater) {  
   return (dateLater.getTime() - dateEarly.getTime()) / (24 * 60 * 60 * 1000);  
}

要实现这个更好的方法是使用java.util.Calendar中

/** Using Calendar - THE CORRECT WAY**/  
public static long daysBetween(Calendar startDate, Calendar endDate) {  
  Calendar date = (Calendar) startDate.clone();  
  long daysBetween = 0;  
  while (date.before(endDate)) {  
    date.add(Calendar.DAY_OF_MONTH, 1);  
    daysBetween++;  
  }  
  return daysBetween;  
}

有你可以找到日期和时间之间的差很多方面。其中之一，我知道的是最简单的方式：

      Calendar calendar1 = Calendar.getInstance();
      Calendar calendar2 = Calendar.getInstance();
      calendar1.set(2012, 04, 02);
      calendar2.set(2012, 04, 04);
      long milsecs1= calendar1.getTimeInMillis();
      long milsecs2 = calendar2.getTimeInMillis();
      long diff = milsecs2 - milsecs1;
      long dsecs = diff / 1000;
      long dminutes = diff / (60 * 1000);
      long dhours = diff / (60 * 60 * 1000);
      long ddays = diff / (24 * 60 * 60 * 1000);

      System.out.println("Your Day Difference="+ddays);

print语句只是一个例子 - 你可以格式化，你喜欢的方式。

。

由于这里的所有答案都是正确的，但使用旧版 java 或 3rd 方库，如 joda 或类似的库，我将使用 new 来放弃另一种方式 java.time Java 8 及更高版本中的类。看 甲骨文教程.

使用 LocalDate 和 ChronoUnit:

LocalDate d1 = LocalDate.of(2017, 5, 1);
LocalDate d2 = LocalDate.of(2017, 5, 18);

long days = ChronoUnit.DAYS.between(d1, d2);
System.out.println( days );

以毫秒为单位减去日期的作品（如在另一篇文章中所描述的），但你的的应用于结算日期的时间部分时，使用HOUR_OF_DAY而不是HOUR：

public static final long MSPERDAY = 60 * 60 * 24 * 1000;
...
final Calendar dateStartCal = Calendar.getInstance();
dateStartCal.setTime(dateStart);
dateStartCal.set(Calendar.HOUR_OF_DAY, 0); // Crucial.
dateStartCal.set(Calendar.MINUTE, 0);
dateStartCal.set(Calendar.SECOND, 0);
dateStartCal.set(Calendar.MILLISECOND, 0);
final Calendar dateEndCal = Calendar.getInstance();
dateEndCal.setTime(dateEnd);
dateEndCal.set(Calendar.HOUR_OF_DAY, 0); // Crucial.
dateEndCal.set(Calendar.MINUTE, 0);
dateEndCal.set(Calendar.SECOND, 0);
dateEndCal.set(Calendar.MILLISECOND, 0);
final long dateDifferenceInDays = ( dateStartCal.getTimeInMillis()
                                  - dateEndCal.getTimeInMillis()
                                  ) / MSPERDAY;
if (dateDifferenceInDays > 15) {
    // Do something if difference > 15 days
}

如果你不想使用JodaTime或类似的，最好的解决办法可能是这样的：

final static long MILLIS_PER_DAY = 24 * 3600 * 1000;
long msDiff= date1.getTime() - date2.getTime();
long daysDiff = Math.round(msDiff / ((double)MILLIS_PER_DAY));

每天毫秒的数量并不总是相同的（因为夏令时和闰秒的），但它是非常接近，并且在由于日光节约时间至少偏差抵消在更长的周期。因此分割，然后舍入将给出一个正确的结果（至少只要使用不含怪异时间本地日历跳到比DST其他和闰秒）。

请注意，这仍然假定date1和date2被设定为一天的同一时间。对于一天的不同时间，你首先必须定义什么是“日期的差异”是指，由乔恩斯基特指出。

看一看约达时间时，这是一种改进的日期/时间API Java和能很好地工作斯卡拉。

让我告诉乔达间隔和天之间的区别：

DateTime start = new DateTime(2012, 2, 6, 10, 44, 51, 0);
DateTime end = new DateTime(2012, 2, 6, 11, 39, 47, 1);
Interval interval = new Interval(start, end);
Period period = interval.toPeriod();
System.out.println(period.getYears() + " years, " + period.getMonths() + " months, " + period.getWeeks() + " weeks, " + period.getDays() + " days");
System.out.println(period.getHours() + " hours, " + period.getMinutes() + " minutes, " + period.getSeconds() + " seconds ");
//Result is:
//0 years, 0 months, *1 weeks, 1 days*
//0 hours, 54 minutes, 56 seconds 

//Period can set PeriodType,such as PeriodType.yearMonthDay(),PeriodType.yearDayTime()...
Period p = new Period(start, end, PeriodType.yearMonthDayTime());
System.out.println(p.getYears() + " years, " + p.getMonths() + " months, " + p.getWeeks() + " weeks, " + p.getDays() + "days");
System.out.println(p.getHours() + " hours, " + p.getMinutes() + " minutes, " + p.getSeconds() + " seconds ");
//Result is:
//0 years, 0 months, *0 weeks, 8 days*
//0 hours, 54 minutes, 56 seconds

如果您需要格式化返回字符串像 “2天03H42米07S”，尝试：

public String fill2(int value)
{
    String ret = String.valueOf(value);

    if (ret.length() < 2)
        ret = "0" + ret;            
    return ret;
}

public String get_duration(Date date1, Date date2)
{                   
    TimeUnit timeUnit = TimeUnit.SECONDS;

    long diffInMilli = date2.getTime() - date1.getTime();
    long s = timeUnit.convert(diffInMilli, TimeUnit.MILLISECONDS);

    long days = s / (24 * 60 * 60);
    long rest = s - (days * 24 * 60 * 60);
    long hrs = rest / (60 * 60);
    long rest1 = rest - (hrs * 60 * 60);
    long min = rest1 / 60;      
    long sec = s % 60;

    String dates = "";
    if (days > 0) dates = days + " Days ";

    dates += fill2((int) hrs) + "h ";
    dates += fill2((int) min) + "m ";
    dates += fill2((int) sec) + "s ";

    return dates;
}

检查例如这里 http://www.roseindia.net/java/beginners/DateDifferent的.shtml 本实施例中给你以天，小时，分钟，秒和秒毫的差：）

import java.util.Calendar;
import java.util.Date;

public class DateDifferent {
    public static void main(String[] args) {
        Date date1 = new Date(2009, 01, 10);
        Date date2 = new Date(2009, 07, 01);
        Calendar calendar1 = Calendar.getInstance();
        Calendar calendar2 = Calendar.getInstance();
        calendar1.setTime(date1);
        calendar2.setTime(date2);
        long milliseconds1 = calendar1.getTimeInMillis();
        long milliseconds2 = calendar2.getTimeInMillis();
        long diff = milliseconds2 - milliseconds1;
        long diffSeconds = diff / 1000;
        long diffMinutes = diff / (60 * 1000);
        long diffHours = diff / (60 * 60 * 1000);
        long diffDays = diff / (24 * 60 * 60 * 1000);
        System.out.println("\nThe Date Different Example");
        System.out.println("Time in milliseconds: " + diff + " milliseconds.");
        System.out.println("Time in seconds: " + diffSeconds + " seconds.");
        System.out.println("Time in minutes: " + diffMinutes + " minutes.");
        System.out.println("Time in hours: " + diffHours + " hours.");
        System.out.println("Time in days: " + diffDays + " days.");
    }
}

使用GMT时区，以获得日历的一个实例，使用日历类的设定方法中设定的时间。的GMT时区具有0偏移（并不重要）和夏令时标志设置为假。

    final Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));

    cal.set(Calendar.YEAR, 2011);
    cal.set(Calendar.MONTH, 9);
    cal.set(Calendar.DAY_OF_MONTH, 29);
    cal.set(Calendar.HOUR, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    final Date startDate = cal.getTime();

    cal.set(Calendar.YEAR, 2011);
    cal.set(Calendar.MONTH, 12);
    cal.set(Calendar.DAY_OF_MONTH, 21);
    cal.set(Calendar.HOUR, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    final Date endDate = cal.getTime();

    System.out.println((endDate.getTime() - startDate.getTime()) % (1000l * 60l * 60l * 24l));

以下代码可以给你所需的输出：

String startDate = "Jan 01 2015";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMM dd yyyy");
LocalDate date = LocalDate.parse(startDate, formatter);

String currentDate = "Feb 11 2015";
LocalDate date1 = LocalDate.parse(currentDate, formatter);

System.out.println(date1.toEpochDay() - date.toEpochDay());

public static String getDifferenceBtwTime(Date dateTime) {

    long timeDifferenceMilliseconds = new Date().getTime() - dateTime.getTime();
    long diffSeconds = timeDifferenceMilliseconds / 1000;
    long diffMinutes = timeDifferenceMilliseconds / (60 * 1000);
    long diffHours = timeDifferenceMilliseconds / (60 * 60 * 1000);
    long diffDays = timeDifferenceMilliseconds / (60 * 60 * 1000 * 24);
    long diffWeeks = timeDifferenceMilliseconds / (60 * 60 * 1000 * 24 * 7);
    long diffMonths = (long) (timeDifferenceMilliseconds / (60 * 60 * 1000 * 24 * 30.41666666));
    long diffYears = (long)(timeDifferenceMilliseconds / (1000 * 60 * 60 * 24 * 365));

    if (diffSeconds < 1) {
        return "one sec ago";
    } else if (diffMinutes < 1) {
        return diffSeconds + " seconds ago";
    } else if (diffHours < 1) {
        return diffMinutes + " minutes ago";
    } else if (diffDays < 1) {
        return diffHours + " hours ago";
    } else if (diffWeeks < 1) {
        return diffDays + " days ago";
    } else if (diffMonths < 1) {
        return diffWeeks + " weeks ago";
    } else if (diffYears < 12) {
        return diffMonths + " months ago";
    } else {
        return diffYears + " years ago";
    }
}

注意：和的startDate是endDates - > java.util.Date 

import org.joda.time.Duration;
import org.joda.time.Interval;
// Use .getTime() unless it is a joda DateTime object
Interval interval = new Interval(startDate.getTime(), endDate.getTime());
Duration period = interval.toDuration();
//gives the number of days elapsed between start 
period.getStandardDays();

和结束日期

类似天，你还可以得到小时，分钟和秒。

period.getStandardHours();
period.getStandardMinutes();
period.getStandardSeconds();

int daysDiff = (date1.getTime() - date2.getTime()) / MILLIS_PER_DAY;

做最好的事情是

(Date1-Date2)/86 400 000

这数是在一天的毫秒数。

一个日期，其他日期为您提供毫秒的差异。

收集在一个的双变量中的答案。

这可能是做的最直接的方式 - 也许是因为我一直在现在Java编码（以其无可否认笨重的日期和时间库）一段时间，但该代码看起来“简单而漂亮的”给我！

您对结果满意正在以毫秒为单位返回，或者是你的问题的一部分，你会更喜欢有它在一些替代格式返回？

不使用标准的API，没有。你可以滚你自己做这样的事情：

class Duration {
    private final TimeUnit unit;
    private final long length;
    // ...
}

或者你也可以使用乔达：

DateTime a = ..., b = ...;
Duration d = new Duration(a, b);

只要回答最初的问题：

将以下代码在像长getAge（函数）{} 

Date dahora = new Date();
long MillisToYearsByDiv = 1000l *60l * 60l * 24l * 365l;
long javaOffsetInMillis = 1990l * MillisToYearsByDiv;
long realNowInMillis = dahora.getTime() + javaOffsetInMillis;
long realBirthDayInMillis = this.getFechaNac().getTime() + javaOffsetInMillis;
long ageInMillis = realNowInMillis - realBirthDayInMillis;

return ageInMillis / MillisToYearsByDiv;

在这里最重要的是乘除时长的数字工作。当然，该偏移的Java应用在其日期的演算。

：）

由于议题被标记有Scala中，

import scala.concurrent.duration._
val diff = (System.currentTimeMillis() - oldDate.getTime).milliseconds
val diffSeconds = diff.toSeconds
val diffMinutes = diff.toMinutes
val diffHours = diff.toHours
val diffDays = diff.toDays

下面是在O（1）没有任何依赖关系的正确的Java 7的解决方案。

public static int countDaysBetween(Date date1, Date date2) {

    Calendar c1 = removeTime(from(date1));
    Calendar c2 = removeTime(from(date2));

    if (c1.get(YEAR) == c2.get(YEAR)) {

        return Math.abs(c1.get(DAY_OF_YEAR) - c2.get(DAY_OF_YEAR)) + 1;
    }
    // ensure c1 <= c2
    if (c1.get(YEAR) > c2.get(YEAR)) {
        Calendar c = c1;
        c1 = c2;
        c2 = c;
    }
    int y1 = c1.get(YEAR);
    int y2 = c2.get(YEAR);
    int d1 = c1.get(DAY_OF_YEAR);
    int d2 = c2.get(DAY_OF_YEAR);

    return d2 + ((y2 - y1) * 365) - d1 + countLeapYearsBetween(y1, y2) + 1;
}

private static int countLeapYearsBetween(int y1, int y2) {

    if (y1 < 1 || y2 < 1) {
        throw new IllegalArgumentException("Year must be > 0.");
    }
    // ensure y1 <= y2
    if (y1 > y2) {
        int i = y1;
        y1 = y2;
        y2 = i;
    }

    int diff = 0;

    int firstDivisibleBy4 = y1;
    if (firstDivisibleBy4 % 4 != 0) {
        firstDivisibleBy4 += 4 - (y1 % 4);
    }
    diff = y2 - firstDivisibleBy4 - 1;
    int divisibleBy4 = diff < 0 ? 0 : diff / 4 + 1;

    int firstDivisibleBy100 = y1;
    if (firstDivisibleBy100 % 100 != 0) {
        firstDivisibleBy100 += 100 - (firstDivisibleBy100 % 100);
    }
    diff = y2 - firstDivisibleBy100 - 1;
    int divisibleBy100 = diff < 0 ? 0 : diff / 100 + 1;

    int firstDivisibleBy400 = y1;
    if (firstDivisibleBy400 % 400 != 0) {
        firstDivisibleBy400 += 400 - (y1 % 400);
    }
    diff = y2 - firstDivisibleBy400 - 1;
    int divisibleBy400 = diff < 0 ? 0 : diff / 400 + 1;

    return divisibleBy4 - divisibleBy100 + divisibleBy400;
}


public static Calendar from(Date date) {

    Calendar c = Calendar.getInstance();
    c.setTime(date);

    return c;
}


public static Calendar removeTime(Calendar c) {

    c.set(HOUR_OF_DAY, 0);
    c.set(MINUTE, 0);
    c.set(SECOND, 0);
    c.set(MILLISECOND, 0);

    return c;
}

通过所有其他的答案涉水，保持Java 7日期型，但更确切地说/标准与Java 8 DIFF方法后，

public static long daysBetweenDates(Date d1, Date d2) {
    Instant instant1 = d1.toInstant();
    Instant instant2 = d2.toInstant();
    long diff = ChronoUnit.DAYS.between(instant1, instant2);
    return diff;
}

尝试这样：

int epoch = (int) (new java.text.SimpleDateFormat("MM/dd/yyyy HH:mm:ss").parse("01/01/1970  00:00:00").getTime() / 1000);

可以在解析编辑该字符串（）方法PARAM。

许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top