2 つの Java 日付インスタンスの差の計算

https://stackoverflow.com/questions/1555262

20-09-2019
|

質問

Java を使用しています java.util.Date Scala のクラスを比較したい Date オブジェクトと現在時刻。getTime() を使用してデルタを計算できることはわかっています。

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

ただし、これでは私に残ります long ミリ秒を表します。時間の差分を取得する、より簡単で優れた方法はありますか?

解決

JDK Date 残念ながら API がひどく壊れています。使用することをお勧めします Joda タイムライブラリ.

Joda Time には時間の概念があります間隔:

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

編集：ちなみに、Jodaには2つのコンセプトがあります。 Interval 2 つの時刻の間の時間間隔を表すため (午前 8 時から午前 10 時までの時間を表す)、 Duration 実際の時間境界を持たない時間の長さを表します（例:2 時間を表します!)

時間の比較のみを重視する場合、ほとんどの場合、 Date 実装 (JDK のものを含む) Comparable を使用できるようにするインターフェイス Comparable.compareTo()

他のヒント

単純な diff (ライブラリなし)

/**
 * 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 enum。

人間が判読できる差分 (ライブラリなし)

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}, 、注文した単位で。

そのマップを使いやすい文字列に変換するだけです。

警告

上記のコードスニペットは、2 つの瞬間間の単純な差分を計算します。で説明されているように、夏時間の切り替え中に問題が発生する可能性があります。この郵便受け. 。つまり、時間を指定せずに日付間の差分を計算すると、日や時間が欠落する可能性があります。

私の意見では、日付の差分は、特に日に関しては主観的なものです。してもいいです：

24 時間の経過時間をカウントします。日+1 - 日 = 1 日 = 24 時間
夏時間を考慮して経過時間をカウントします。日 + 1 - 日 = 1 = 24 時間 (ただし、深夜時間と夏時間を使用すると、0 日と 23 時間になる可能性があります)
の数を数えます day switches, これは、経過時間がわずか 2 時間であっても (夏時間がある場合は 1 時間)、日+1 午後 1 時 - 日午前 11 時 = 1 日を意味します。

日付の差分の定義が最初のケースと一致する場合、私の答えは有効です

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

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

あなたは地元の日付を見れば差は休みかもしれので、これは、UTC日付で動作することに注意してください。そしてそれは地元日付で正常に動作するために得ることは夏時間のために完全に異なるアプローチが必要です。

問題をより明確に定義する必要があります。あなた できた 2 つの間のミリ秒数を取得するだけです Date たとえば、オブジェクトを 24 時間のミリ秒数で割ります...しかし：

これにはタイムゾーンは考慮されません - Date 常に UTC です
これには夏時間は考慮されません (たとえば、1 日が 23 時間しかない場合もあります)。
UTC 内でも、8 月 16 日午後 11 時から 8 月 18 日午前 2 時までは何日ありますか?27時間しかないので、1日ということですか？それとも 3 つの日付が含まれるため、3 日間にする必要がありますか?

を使用して、 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

詳細については、を参照してください。オラクルのチュートリアルそしてその ISO8601 標準。

先生

時代遅れのものを変換する 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`

賢明な標準 ISO8601 時間の範囲を年、月、日、時間などの数として簡潔なテキスト表現で定義します。標準ではそのようなスパンを「間隔. 。フォーマットは PnYnMnDTnHnMnS どこ P 「期間」を意味します。 T 日付部分と時刻部分を区切っており、その間には数字とその後に文字が続きます。

例:

P3Y6M4DT12H30M5S
3年6ヶ月4日12時間30分5秒
PT4H30M
4時間半

java.time

の java.time Java 8 以降に組み込まれたフレームワークが、面倒な古いフレームワークに取って代わります。 java.util.Date/java.util.Calendar クラス。新しいクラスは、大成功を収めたクラスからインスピレーションを受けています。ジョーダタイム後継フレームワークとして意図されており、コンセプトは似ていますが、再設計されています。によって定義されます JSR 310. 。によって延長されました ThreeTen-Extra プロジェクト。を参照してください。チュートリアル.

一瞬

の Instant クラスはタイムライン上の瞬間を表します。 UTC の解像度でナノ秒 (小数点以下 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 クラスは、時間の範囲を年、月、日、時間、分、秒の数として表すこの概念を 2 つに分割しました。

Period 何年も、何か月も、何日も
Duration 日、時間、分、秒

ここに一例を示します。

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

コンソールにダンプします。

両方 Period そして Duration 使用 ISO8601 値の文字列表現を生成するための標準。

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 日の部分、時間の部分、分の部分、および秒の部分を取得します。

期間全体の合計の日数、時間、分、秒、ミリ秒、またはナノ秒を取得できます。

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 SE8 そして SE9 以降
- 内蔵。
- 実装がバンドルされている標準 Java API の一部。
- Java 9 では、いくつかのマイナーな機能と修正が追加されています。
Java SE6 そして SE7
- java.time 機能の多くは、Java 6 および 7 にバックポートされています。 ThreeTen バックポート.
アンドロイド
- の スリーテンABP プロジェクトが適応する ThreeTen バックポート (前述) 特に Android の場合。
- 見る 使い方….

の ThreeTen-Extra プロジェクトは追加のクラスで 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時間を持つことができます）期日の複雑さに不正確と間違った期待につながるかもしれないということです。

ミリ秒のアプローチを使用すると、一部のロケールで問題を引き起こすことができます。

は1日であるべきで、例えば、二つの日付2007年3月24日及び2007年3月25日との間の差を取ることができます。

あなたは、英国でこれを実行する場合は、

しかし、ミリ秒のルートを使用して、あなたは、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または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 HOUR_OF_DAYを使用していないために（別の記事で説明したように）ミリ秒の作品に日付を減算していますが、のHAVE を

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とScalaので正常に動作する必要があります。

私はジョダ間隔と日数の違いをお見せしましょう

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日間03Hの42メートルの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タイムゾーンカレンダーのインスタンスを取得するには、Calendarクラスのsetメソッドを使用して時刻を設定します。 GMTタイムゾーンが0オフセットしている（実際には重要ではありません）と夏時間フラグがfalseに設定されます。

    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

その数は日中にのミリ秒の数です。

1つの日付、その他の日は、あなたのミリ秒単位の差を与えます。

をダブルの変数で答えを収集します。

それはおそらくそれを行うための最も簡単な方法です - おそらく私が今しばらくの間（その確か不格好日時ライブラリと）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は日付のその計算に適用されることにオフセットます。

：）

質問がスカラでタグ付けされているので、

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