Ich verwende Javas java.util.DateKlasse in Scala und möchte ein DateObjekt und die aktuelle Zeit vergleichen. Ich weiß, dass ich das Delta mit getTime () berechnen kann:

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

Dies lässt mir jedoch nur longMillisekunden. Gibt es einen einfacheren und schöneren Weg, um ein Zeitdelta zu erhalten?

Die JDK- DateAPI ist leider schrecklich kaputt. Ich empfehle die Verwendung der Joda Time Bibliothek .

Joda Time hat ein Konzept des Zeitintervalls :

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

BEARBEITEN: Joda hat übrigens zwei Konzepte: Intervalfür die Darstellung eines Zeitintervalls zwischen zwei Zeitpunkten (repräsentieren die Zeit zwischen 8 und 10 Uhr) und eines Duration, das eine Zeitspanne ohne die tatsächlichen Zeitgrenzen darstellt (z. B. zwei Stunden!)

Wenn Sie sich nur für Zeitvergleiche interessieren, Dateimplementieren die meisten Implementierungen (einschließlich der JDK-Implementierung) eine ComparableSchnittstelle, über die Sie die verwenden könnenComparable.compareTo()

Einfaches Diff (ohne 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);
}

Und dann können Sie anrufen:

getDateDiff(date1,date2,TimeUnit.MINUTES);

um den Unterschied der 2 Daten in Minuten zu erhalten.

TimeUnitist java.util.concurrent.TimeUniteine Standard-Java-Aufzählung, die von Nanos bis zu Tagen reicht.

Vom Menschen lesbarer Diff (ohne Bibliothek)

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

Die Ausgabe ist so etwas wie Map:{DAYS=1, HOURS=3, MINUTES=46, SECONDS=40, MILLISECONDS=0, MICROSECONDS=0, NANOSECONDS=0}mit den bestellten Einheiten.

Sie müssen diese Karte nur in eine benutzerfreundliche Zeichenfolge konvertieren.

Warnung

Die obigen Codefragmente berechnen einen einfachen Unterschied zwischen zwei Zeitpunkten. Es kann Probleme während eines Sommerzeitschalters verursachen, wie in diesem Beitrag erläutert . Dies bedeutet, wenn Sie den Unterschied zwischen Daten ohne Uhrzeit berechnen, fehlt möglicherweise ein Tag / eine Stunde.

Meiner Meinung nach ist der Datumsunterschied subjektiv, besonders an Tagen. Du darfst:

• Zählen Sie die Anzahl der verstrichenen 24 Stunden: Tag + 1 - Tag = 1 Tag = 24 Stunden

• Zählen Sie die Anzahl der verstrichenen Zeit und achten Sie dabei auf die Sommerzeit: Tag + 1 - Tag = 1 = 24 Stunden (bei Mitternacht und Sommerzeit können es jedoch 0 Tage und 23 Stunden sein).

• Zählen Sie die Anzahl von day switches, dh Tag + 1 1 Uhr - Tag 11 Uhr = 1 Tag, auch wenn die verstrichene Zeit nur 2 Stunden beträgt (oder 1 Stunde, wenn eine Sommerzeit vorhanden ist: p).

Meine Antwort ist gültig, wenn Ihre Definition des Datumsunterschieds an Tagen mit dem 1. Fall übereinstimmt

Mit JodaTime

Wenn Sie JodaTime verwenden, können Sie den Diff für 2 Instants (Millies Backed ReadableInstant) -Daten erhalten mit:

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

Sie können den Diff aber auch für lokale Daten / Zeiten abrufen:

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

Beachten Sie, dass dies mit UTC-Daten funktioniert. Wenn Sie sich die lokalen Daten ansehen, kann der Unterschied ein freier Tag sein. Und damit es mit lokalen Daten richtig funktioniert, ist aufgrund der Sommerzeit ein völlig anderer Ansatz erforderlich.

Verwenden des in Java 8+ integrierten java.time- Frameworks:

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

Ausgabe:

ISO-8601: PT24H10M

Minuten: 1450

Weitere Informationen finden Sie im Oracle Tutorial und im ISO 8601- Standard.

Sie müssen Ihr Problem klarer definieren. Sie können einfach die Anzahl der Millisekunden zwischen den beiden DateObjekten nehmen und durch die Anzahl der Millisekunden in 24 Stunden dividieren, zum Beispiel ... aber:

• Dies berücksichtigt keine Zeitzonen - Dateist immer in UTC
• Dabei wird die Sommerzeit nicht berücksichtigt (wo es beispielsweise Tage geben kann, die nur 23 Stunden lang sind).
• Wie viele Tage gibt es innerhalb von UTC vom 16. August um 23 Uhr bis zum 18. August um 2 Uhr morgens? Es sind nur 27 Stunden, bedeutet das also einen Tag? Oder sollten es drei Tage sein, weil es drei Daten abdeckt?

tl; dr

Konvertieren Sie Ihre veralteten java.util.DateObjekte in deren Ersatz java.time.Instant. Berechnen Sie dann die verstrichene Zeit als 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 Format: PnYnMnDTnHnMnS

Die sinnvolle Norm ISO 8601 definiert eine präzise Textdarstellung einer Zeitspanne als Anzahl von Jahren, Monaten, Tagen, Stunden usw. Die Norm nennt eine solche Zeitspanne eine Dauer . Das Format ist, PnYnMnDTnHnMnSwo das PMittel "Punkt" bedeutet, das Tden Datumsabschnitt vom Zeitabschnitt trennt und dazwischen Zahlen stehen, gefolgt von einem Buchstaben.

Beispiele:

• P3Y6M4DT12H30M5S
  drei Jahre, sechs Monate, vier Tage, zwölf Stunden, dreißig Minuten und fünf Sekunden
• PT4H30M
  Viereinhalb Stunden

java.time

Das in Java 8 und höher integrierte Java.time- Framework ersetzt die problematischen alten java.util.Date/ java.util.CalendarKlassen. Die neuen Klassen sind von dem äußerst erfolgreichen Joda-Time- Framework inspiriert , das als Nachfolger gedacht ist. Das Konzept ist ähnlich, aber neu aufgebaut. Definiert durch JSR 310 . Erweitert um das ThreeTen-Extra- Projekt. Siehe das Tutorial .

Moment

Die InstantKlasse repräsentiert einen Moment auf der Zeitachse in UTC mit einer Auflösung von Nanosekunden (bis zu neun (9) Stellen eines Dezimalbruchs).

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

Vermeiden Sie am besten ältere Klassen wie Date/ Calendar. Wenn Sie jedoch mit altem Code interagieren müssen , der noch nicht auf java.time aktualisiert wurde , konvertieren Sie hin und her. Rufen Sie neue Konvertierungsmethoden auf, die den alten Klassen hinzugefügt wurden. Rufen Sie java.util.Datean Instant, um von a nach a zu wechseln Date::toInstant.

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

Zeitspanne

Die java.time-Klassen haben diese Idee, eine Zeitspanne als Anzahl von Jahren, Monaten, Tagen, Stunden, Minuten, Sekunden in zwei Hälften darzustellen, in zwei Hälften geteilt:

• Period seit Jahren, Monaten, Tagen
• Duration für Tage, Stunden, Minuten, Sekunden

Hier ist ein Beispiel.

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

Dump zur Konsole.

Beide Periodund Durationverwenden den ISO 8601- Standard zum Generieren einer String-Darstellung ihres Werts.

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

jetzt: 2015-11-26T00: 46: 48.016-05: 00 [Amerika / Montreal] bis Zukunft: 2015-11-26T00: 46: 48.016-05: 00 [Amerika / Montreal] = PT1H3M

Java 9 fügt Methoden hinzu Duration, um den Tag-, Stunden-, Minuten- und Sekunden-Teil abzurufen.

Sie können die Gesamtzahl der Tage oder Stunden oder Minuten oder Sekunden oder Millisekunden oder Nanosekunden in der gesamten Dauer abrufen.

long totalHours = duration.toHours();

In Java 9 Durationerhält die Klasse neue Methoden zum Zurückgeben der verschiedenen Teile von Tagen, Stunden, Minuten, Sekunden, Millisekunden / Nanosekunden. Rufen Sie die to…PartMethoden: toDaysPart(), toHoursPart(), und so weiter.

ChronoUnit

Wenn Sie sich nur für eine einfachere, größere Zeitgranularität interessieren, z. B. "Anzahl der verstrichenen Tage", verwenden Sie die ChronoUnitAufzählung.

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

Ein anderes Beispiel.

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

120

Über java.time

Das java.time- Framework ist in Java 8 und höher integriert. Diese Klassen verdrängen die lästigen alten Legacy - Datum-Zeit - Klassen wie java.util.Date, Calendar, & SimpleDateFormat.

Das Joda-Time- Projekt, das sich jetzt im Wartungsmodus befindet , empfiehlt die Migration zu java.time.

Weitere Informationen finden Sie im Oracle-Lernprogramm . Suchen Sie im Stapelüberlauf nach vielen Beispielen und Erklärungen. Die Spezifikation ist JSR 310 .

Woher bekomme ich die java.time-Klassen?

• Java SE 8 und SE 9 und höher
  • Eingebaut.
  • Teil der Standard-Java-API mit einer gebündelten Implementierung.
  • Java 9 fügt einige kleinere Funktionen und Korrekturen hinzu.
• Java SE 6 und SE 7
  • Ein Großteil der Funktionen von java.time wird in ThreeTen-Backport auf Java 6 & 7 zurückportiert .
• Android
  • Das ThreeTenABP- Projekt passt ThreeTen-Backport (oben erwähnt) speziell für Android an.
  • Siehe Verwendung… .

Das ThreeTen-Extra- Projekt erweitert java.time um zusätzliche Klassen. Dieses Projekt ist ein Testfeld für mögliche zukünftige Ergänzungen von java.time. Sie können einige nützliche Klassen hier wie finden Interval, YearWeek, YearQuarter, und mehr .

Joda-Zeit

UPDATE: Das Joda-Time- Projekt befindet sich jetzt im Wartungsmodus. Das Team empfiehlt die Migration zu den Klassen java.time . Ich lasse diesen Abschnitt für die Geschichte intakt.

Die Joda-Time-Bibliothek verwendet für ihre Standardeinstellungen ISO 8601. Die PeriodKlasse analysiert und generiert diese PnYnMnDTnHnMnS-Zeichenfolgen.

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

Rendert:

period: PT4H30M

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

https://www.joda.org/joda-time/faq.html#datediff

Eine etwas einfachere Alternative:

System.currentTimeMillis() - oldDate.getTime()

Was "schöner" betrifft: Nun, was genau brauchst du? Das Problem bei der Darstellung der Zeitdauer als Anzahl von Stunden und Tagen usw. besteht darin, dass dies aufgrund der Komplexität der Daten zu Ungenauigkeiten und falschen Erwartungen führen kann (z. B. können Tage aufgrund der Sommerzeit 23 oder 25 Stunden haben).

Die Verwendung des Millisekunden-Ansatzes kann in einigen Regionen zu Problemen führen.

Nehmen wir zum Beispiel, die Differenz zwischen den beiden Daten 24.03.2007 und 25.03.2007 sollte 1 Tag betragen.

Wenn Sie jedoch die Millisekunden-Route verwenden, erhalten Sie 0 Tage, wenn Sie dies in Großbritannien ausführen!

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

Eine bessere Möglichkeit, dies zu implementieren, ist die Verwendung von 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;  
}  

Es gibt viele Möglichkeiten, wie Sie den Unterschied zwischen Datum und Uhrzeit feststellen können. Eine der einfachsten Möglichkeiten, die ich kenne, wäre:

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

Die print-Anweisung ist nur ein Beispiel - Sie können sie nach Ihren Wünschen formatieren.

Da alle Antworten hier korrekt sind, aber ältere Java- oder Drittanbieter-Bibliotheken wie joda oder ähnliches verwenden, werde ich einfach neue Java.time- Klassen in Java 8 und höher verwenden. Siehe Oracle Tutorial .

Verwenden Sie LocalDateund 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 );

Das Subtrahieren der Daten in Millisekunden funktioniert (wie in einem anderen Beitrag beschrieben), aber Sie müssen HOUR_OF_DAY und nicht HOUR verwenden, wenn Sie die Zeitteile Ihrer Daten löschen:

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
}

Wenn Sie JodaTime oder ähnliches nicht verwenden möchten, ist die beste Lösung wahrscheinlich folgende:

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

Die Anzahl der ms pro Tag ist nicht immer gleich (aufgrund der Sommerzeit und der Schaltsekunden), liegt jedoch sehr nahe beieinander, und zumindest Abweichungen aufgrund der Sommerzeit werden über längere Zeiträume aufgehoben. Daher ergibt das Teilen und anschließende Runden ein korrektes Ergebnis (zumindest solange der verwendete lokale Kalender keine anderen seltsamen Zeitsprünge als Sommerzeit und Schaltsekunden enthält).

Beachten Sie, dass dies immer noch davon ausgeht date1und date2auf dieselbe Tageszeit eingestellt ist. Für verschiedene Tageszeiten müssten Sie zuerst definieren, was "Datumsunterschied" bedeutet, wie von Jon Skeet hervorgehoben.

Schauen Sie sich Joda Time an , eine verbesserte Datums- / Uhrzeit-API für Java, die mit Scala problemlos funktionieren sollte.

Lassen Sie mich den Unterschied zwischen Joda-Intervall und Tagen zeigen:

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 

Wenn Sie eine formatierte Rückgabezeichenfolge wie "2 Days 03h 42m 07s" benötigen, versuchen Sie Folgendes:

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;
}

Hinweis: startDate und endDates sind -> 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();

und Enddatum

Ähnlich wie bei Tagen können Sie auch Stunden, Minuten und Sekunden erhalten

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

Beispiel hier ansehen http://www.roseindia.net/java/beginners/DateDifferent.shtml Dieses Beispiel gibt Ihnen einen Unterschied in Tagen, Stunden, Minuten, Sekunden und Millisekunden :).

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.");
    }
}

Verwenden Sie die GMT-Zeitzone, um eine Instanz des Kalenders abzurufen. Legen Sie die Zeit mithilfe der festgelegten Methode der Kalenderklasse fest. Die GMT-Zeitzone hat einen Offset von 0 (nicht wirklich wichtig) und ein Sommerzeit-Flag auf false gesetzt.

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

Der folgende Code kann Ihnen die gewünschte Ausgabe geben:

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";
    }
}   

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

Das Beste ist

(Date1-Date2)/86 400 000 

Diese Zahl ist die Anzahl der Millisekunden pro Tag.

Ein Datum und ein anderes Datum geben den Unterschied in Millisekunden an.

Sammeln Sie die Antwort in einer doppelten Variablen.

Hier ist eine korrekte Java 7-Lösung in O (1) ohne Abhängigkeiten.

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;
}

Das ist wahrscheinlich der einfachste Weg, dies zu tun - vielleicht liegt es daran, dass ich schon seit einiger Zeit in Java (mit seinen zugegebenermaßen klobigen Datums- und Zeitbibliotheken) codiere, aber dieser Code sieht für mich "einfach und nett" aus!

Sind Sie mit der Rückgabe des Ergebnisses in Millisekunden zufrieden oder ist es Teil Ihrer Frage, dass Sie es lieber in einem anderen Format zurückgeben möchten?

Nicht mit der Standard-API, nein. Sie können Ihre eigenen machen, indem Sie so etwas tun:

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

Oder Sie können Joda verwenden :

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

Nur um die erste Frage zu beantworten:

Fügen Sie den folgenden Code in eine Funktion wie Long getAge () {} ein

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;

Das Wichtigste dabei ist, beim Multiplizieren und Dividieren mit langen Zahlen zu arbeiten. Und natürlich der Offset, den Java in seiner Datumsrechnung anwendet.

:) :)

Da die Frage mit Scala markiert ist,

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

Nachdem Sie alle anderen Antworten durchgesehen haben, um den Java 7-Datumstyp beizubehalten, aber mit dem Java 8-Diff-Ansatz präziser / standardisierter zu sein,

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;
}

Versuche dies:

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

Sie können die Zeichenfolge im Parameter parse () -Methoden bearbeiten.