Berechnung der Differenz zwischen zwei Java Datum Instanzen
https://stackoverflow.com/questions/1555262
-
20-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Ich bin mit Java java.util.Date Klasse in Scala und will ein Date Objekt und die aktuelle Zeit zu vergleichen. Ich weiß, dass ich das Delta unter Verwendung getTime berechnen kann ():
(new java.util.Date()).getTime() - oldDate.getTime()
Doch diese nur Blätter mich mit einem long Millisekunden darstellt. Gibt es einen einfacheren, schönen Weg, um eine Zeit Delta zu bekommen?
Lösung
Das JDK Date API ist schrecklich leider kaputt. Ich empfehle, mit Joda Zeitbibliothek .
Joda Zeit hat ein Konzept der Zeit Interval :
Interval interval = new Interval(oldTime, new Instant());
EDIT: Übrigens, Joda hat zwei Konzepte: Interval zur Darstellung eines Zeitintervalls zwischen zwei Zeitpunkten (Zeit von 8.00 Uhr bis 10.00 Uhr darstellen), und einen Duration, die eine Länge der Zeit, ohne die tatsächliche Zeitgrenzen darstellt (zB stellen zwei Stunden!)
Wenn Sie nur über die Zeit comparisions kümmern, die meisten Date Implementierungen (einschließlich des JDK ein) implementiert Comparable-Schnittstelle, die die Comparable.compareTo()
Andere Tipps
Einfacher 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 kann man nennen:
getDateDiff(date1,date2,TimeUnit.MINUTES);
das diff der 2 Termine in Minuten Einheit erhalten.
TimeUnit ist java.util.concurrent.TimeUnit, ein Standard-Java-Enum von nanos zu Tage gehen.
die Menschen lesbare diff (ohne 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;
}
Der Ausgang ist so etwas wie Map:{DAYS=1, HOURS=3, MINUTES=46, SECONDS=40, MILLISECONDS=0, MICROSECONDS=0, NANOSECONDS=0}, wobei die Einheiten bestellt.
Sie haben soeben diese Karte zu einem benutzerfreundlichen String konvertieren.
Warnung
Der obige Code-Schnipsel berechnet, ein einfaches diff zwischen 2 Punkten. Es kann Probleme während eines Sommer Schalter führen, wie erklärt in diesen Beitrag . Dies bedeutet, wenn Sie die diff zwischen Terminen keine Zeit berechnen Sie eine fehlende Tag / Stunde haben.
Meiner Meinung nach dem Datum diff ist eine Art subjektiver, vor allem an den Tagen. Sie können:
-
zählt die Anzahl der 24-Stunden-verstrichene Zeit: Tag + 1 - Tag = 1 Tag = 24 Stunden
-
zählt die Anzahl der verstrichenen Zeit, die Betreuung von Sommerzeit: Tag + 1 - Tag = 1 = 24h (aber Mitternacht Zeit und Sommer verwendet, könnte es sein, 0 Tage und 23 Stunden)
-
die Anzahl des
day switcheszählen, der Tag bedeutet, + 1 01.00 - Tag 11.00 = 1 Tag, auch wenn die verstrichene Zeit nur 2 Stunden (oder 1 Stunde, wenn es eine Tageslicht Einsparung: p)
Meine Antwort ist gültig, wenn Ihre Definition von Datum diff an den Tagen des ersten Fall entspricht
Mit JodaTime
Wenn Sie JodaTime verwenden Sie die diff für 2 Punkte erhalten können (millies gesichert ReadableInstant) Termine mit:
Interval interval = new Interval(oldInstant, new Instant());
Sie können aber auch die diff für lokale Daten / Zeiten erhalten:
// 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 diese Arbeiten mit UTC Daten, so dass die Differenz einen Tag frei sein kann, wenn man sich vor Ort Termine. Und es immer mit lokalen Daten korrekt arbeiten erfordert einen völlig anderen Ansatz aufgrund der Sommerzeit.
Sie müssen Ihr Problem genauer definieren. Sie könnte nehmen Sie nur die Anzahl der Millisekunden zwischen den beiden Date Objekten und dividieren durch die Anzahl der Millisekunden innerhalb von 24 Stunden, zum Beispiel ... aber:
- Das wird keine Zeitzonen berücksichtigen -
Dateist immer in UTC - Das wird die Sommerzeit nicht berücksichtigen (wo es kann Tage sein, die nur 23 Stunden lang, zum Beispiel)
- Auch innerhalb UTC, wie viele Tage gibt es in dem 16. August 23.00 Uhr bis 18. August 02.00? Es ist nur 27 Stunden, so heißt das einen Tag? Oder sollte es drei Tage, weil es drei Tage, deckt?
Mit dem java.time Rahmen in Java gebaut 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());
Ausgabe:
ISO-8601: PT24H10M
Minuten: 1450
Weitere Informationen finden Sie in der Oracle Tutorial und die ISO 8601 Standard.
tl; dr
Konvertieren Sie Ihre veraltete java.util.Date Objekte zu deren Ersatz, java.time.Instant. Dann berechnet 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 Standard ISO 8601 definiert eine kurze textliche Darstellung einer Zeitspanne als Zahl Jahre, Monate, Tage, Stunden, usw. Die Standardgespräche solche eine solche Spanne ein Dauer . Das Format ist PnYnMnDTnHnMnS wo die P Mittel „Periode“, die T den Datumsteil aus dem Zeitteil trennen, und dazwischen sind Zahlen, gefolgt von einem Buchstaben.
Beispiele:
-
P3Y6M4DT12H30M5S
drei Jahre sechs Monate 4 Tage, 12 Stunden, 30 Minuten und fünf Sekunden -
PT4H30M
Viereinhalb Stunden
java.time
Die java.time Rahmen eingebaut in Java 8 und später verdrängt die lästigen alten java.util.Date / java.util.Calendar Klassen. Die neuen Klassen sind inspiriert von dem sehr erfolgreichen Joda-Time Rahmen, sollte als seinen Nachfolger, ähnlich in Konzept, aber neu gestaltet. Definiert durch JSR 310 . Erweitert durch das ThreeTen-Extra Projekt. Sehen Sie sich die Tutorial .
Moment
Die Instant Klasse stellt einen Moment auf der Zeitleiste in UTC mit einer Auflösung von ns (bis zu neun (9) Stellen einer Dezimalbruch).
Instant instant = Instant.now() ; // Capture current moment in UTC.
Best die älteren Klassen wie Date / Calendar zu vermeiden. Aber wenn Sie mit altem Code inter arbeiten muss noch nicht aktualisiert java.time , convert hin und her. Rufen Sie Methoden, um neue Umwandlung in die alten Klassen hinzugefügt. Zum Bewegen von einem java.util.Date zu einem Instant Anruf Date::toInstant .
Instant instant = myJavaUtilDate.toInstant() ; // Convert from legacy `java.util.Date` class to modern `java.time.Instant` class.
Span Zeit
Die java.time Klassen aufgeteilt haben diese Idee, eine Zeitspanne als eine Anzahl von Jahren darstellen, Monate, Tage, Stunden, Minuten, Sekunden in zwei Hälften:
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-Konsole.
Sowohl Period und Duration Verwendung des ISO 8601 Standard zur Erzeugung einer String-Darstellung ihres Wert.
System.out.println ( "now: " + now + " to future: " + now + " = " + duration );
jetzt: 2015-11-26T00: 46: 48,016 bis 05: 00 [America / Montreal] in der Zukunft: 2015.11.26T00: 46: 48,016 bis 05: 00 [America / Montreal] = PT1H3M
Java 9 fügt Methoden Duration die Tage Teil, Stunden Teil Minuten Teil zu bekommen, und Sekunden Teil.
Sie können die Gesamtzahl der Tage oder Stunden oder Minuten oder Sekunden oder Millisekunden oder ns in der gesamten Dauer erhalten.
long totalHours = duration.toHours();
In Java 9 die Duration Klasse bekommt neue Methoden die verschiedenen Teile für die Rückgabe Tage, Stunden, Minuten, Sekunden, Millisekunden / ns. Rufen Sie die to…Part Methoden: toDaysPart(), toHoursPart(), und so weiter
ChronoUnit
Wenn Sie nur über eine einfachere größere Granularität der Zeit egal, wie „Anzahl von Tagen verstrichen“, verwenden Sie die ChronoUnit enum.
long daysElapsed = ChronoUnit.DAYS.between( earlier , later );
Ein weiteres Beispiel.
Instant now = Instant.now();
Instant later = now.plus( Duration.ofHours( 2 ) );
…
long minutesElapsed = ChronoUnit.MINUTES.between( now , later );
120
Über java.time
Die java.time Rahmen ist in Java 8 gebaut und später. Diese Klassen verdrängen die lästigen alten Vermächtnis Datum Zeitklassen wie java.util.Date , Calendar & SimpleDateFormat .
Die Joda-Time Projekt nun in Wartungsmodus , rät Migration zu java.time.
Um mehr zu erfahren, finden Sie in der Oracle Tutorial . Und Stack-Überlauf suchen viele Beispiele und Erklärungen. Spezifikation JSR 310 .
Wo die java.time Klassen erhalten?
- Java SE 8 und SE 9 und später
- Built-in.
- Ein Teil des Standard-Java-API mit einer gebündelten Implementierung.
- Java 9 fügt einige kleinere Features und Korrekturen.
- Java SE 6 und SE 7
- Ein großer Teil der java.time Funktionalität zurückportiert zu Java 6 & 7 in ThreeTen-Backport .
- Android
- Die ThreeTenABP Projekt passt sich ThreeTen-Backport (siehe oben) für Android speziell.
- Siehe So verwenden ... .
Das ThreeTen-Extra Projekt erstreckt java.time mit zusätzlichen Klassen. Dieses Projekt ist eine Bewährungsprobe für eine mögliche zukünftige Ergänzungen java.time. Sie können einige nützliche Klassen hier wie Interval , YearWeek , YearQuarter und mehr .
Joda-Time
UPDATE: Die Joda-Time Projekt ist jetzt in Wartungsmodus , mit dem Team der Beratung Migration auf das java.time Klassen. Ich lasse diesen Abschnitt intakt für Geschichte.
Die Joda-Time-Bibliothek verwendet ISO 8601 für die Standardwerte. Seine Period Klasse analysiert und generiert diese PnYnMnDTnHnMnS Saiten.
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 );
Renders:
period: PT4H30M
Days d = Days.daysBetween(startDate, endDate);
int days = d.getDays();
Eine etwas einfachere Alternative:
System.currentTimeMillis() - oldDate.getTime()
Wie bei „schöner“: gut, was genau brauchen Sie? Das Problem mit dem wiedergebenden Zeitdauern als eine Anzahl von Stunden und Tagen usw. ist, dass es zu Ungenauigkeiten und falschen Erwartungen aufgrund der Komplexität der Daten (zB Tage können die Sommerzeit durch 23 oder 25 Stunden haben) führen kann.
Mit Millisekunden Ansatz können Probleme in einigen Orten führen.
Werfen wir zum Beispiel die Differenz zwischen den beiden Daten 2007.03.24 und 2007.03.25 sollte 1 Tag sein;
Um jedoch die Millisekunden-Route verwenden, werden Sie 0 Tage erhalten, wenn Sie laufen diese in Großbritannien!
/** 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);
}
besserer Weg, dies zu implementieren ist java.util.Calendar verwenden
/** 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 Daten und Zeiten zu finden. Eine der einfachsten Möglichkeiten, das 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 es zu formatieren, wie Sie wie
Da alle hier Antworten sind richtig, aber die Verwendung Vermächtnis Java oder 3rd-Party-Libs wie joda oder ähnliches, werde ich fallen nur eine andere Art und Weise mit neuen java.time Klassen in Java 8 und höher. Siehe Oracle Tutorial .
Verwenden Sie LocalDate und 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 );
Subtrahierend die Daten in Millisekunden Arbeiten (wie in einem anderen Beitrag beschrieben), aber Sie Haben HOUR_OF_DAY zu verwenden und nicht HOUR, wenn die Zeit Teile Ihrer Daten gelöscht werden:
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 nicht verwenden JodaTime oder ähnliches wollen, ist die beste Lösung wahrscheinlich so aus:
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 (wegen der Sommerzeit und Schaltsekunden zu speichern), aber es ist ganz in der Nähe, und zumindest Abweichungen aufgrund von Sommerzeit zunichte macht über längere Zeiträume. Daher teilen und dann ein korrektes Ergebnis geben Rundung (zumindest solange der lokale Kalender nicht enthält seltsame Zeitsprünge andere als DST und Schaltsekunden verwendet wird).
Beachten Sie, dass dies geht davon aus, dass noch date1 und date2 auf die gleiche Tageszeit. Für verschiedene Tageszeiten, müssen Sie zuerst, was „Datumsdifferenz“ Mittel definieren, wie erwähnt von Jon Skeet.
Hier finden Sie aktuelle Joda Zeit , das ein verbessertes Datum / Zeit-API für Java und mit Scala gut funktionieren soll.
Lassen Sie mich Unterschied zwischen Joda Intervall und Tagen:
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ückkehr String wie "2 Tage 03h 42m 07s", versuchen Sie dies:
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;
}
Überprüfen Beispiel hier http://www.roseindia.net/java/beginners/DateDifferent Shtml Dieses Beispiel gibt Ihnen Unterschied in Tagen, Stunden, Minuten, Sekunden und milli sec ist.)
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 GMT Zeitzone eine Instanz des Kalenders zu bekommen, stellen Sie die Zeit, die eingestellte Methode der Calendar-Klasse. Die GMT Zeitzone hat Offset 0 (nicht wirklich wichtig) und Sommerzeit-Flag auf falsch zu speichern.
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));
Code Nach können Sie die gewünschte Ausgabe:
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";
}
}
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 Tage, können Sie auch Stunden, Minuten und Sekunden erhalten
period.getStandardHours();
period.getStandardMinutes();
period.getStandardSeconds();
int daysDiff = (date1.getTime() - date2.getTime()) / MILLIS_PER_DAY;
Das Beste, was zu tun ist,
(Date1-Date2)/86 400 000
Diese Zahl ist die Anzahl der Millisekunden in einem Tag.
Ein Datum anderes Datum gibt Ihnen Unterschied in Millisekunden.
Sammeln Sie die Antwort in einem Doppel Variable.
Das ist wahrscheinlich der einfachste Weg, es zu tun - vielleicht ist es, weil ich in Java (mit seinem zugegebenermaßen klobig Datum und Zeitbibliotheken) für eine Weile, aber das Code sieht „einfach und schön“ mir Codierung worden!
Sind Sie mit dem Ergebnis zufrieden in Millisekunden zurückgegeben wird, oder ein Teil Ihrer Frage ist, dass Sie es in irgendeiner anderen Form zurück haben würden es vorziehen?
Nicht den Standard-API verwenden, nicht. Sie können Ihre eigenen, etwas zu tun, wie dies rollen:
class Duration {
private final TimeUnit unit;
private final long length;
// ...
}
Sie können auch benutzen Joda :
DateTime a = ..., b = ...;
Duration d = new Duration(a, b);
Nur die ursprüngliche Frage zu beantworten:
Setzen Sie den folgenden Code in einer Funktion wie Long 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;
Die wichtigste hier ist, um die Arbeit mit langen Zahlen bei der Multiplikation und Division. Und natürlich die Offset, dass Java in seinem Kalkül der Daten gilt.
:)
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
Hier ist eine richtige 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;
}
Nach dem durch alle anderen Antworten waten, die Java 7 Datumstyp zu halten, aber präzisere / Standard mit dem Java 8 diff Ansatz 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;
}
versuchen, diese:
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 in der Parse () -Methoden param bearbeiten.
