Simple diff (without 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);
}

A potem możesz zadzwonić:

getDateDiff(date1,date2,TimeUnit.MINUTES);

Aby uzyskać diff z 2 dat w jednostce minut.

TimeUnit is java.util.concurrent.TimeUnit, standard Java enum przechodzący od nanos do dni.

Czytelny dla człowieka diff (bez lib)

public static Map<TimeUnit,Long> computeDiff(Date date1, Date date2) {
    long diffInMillies = date2.getTime() - date1.getTime();
    List<TimeUnit> units = new ArrayList<TimeUnit>(EnumSet.allOf(TimeUnit.class));
    Collections.reverse(units);
    Map<TimeUnit,Long> result = new LinkedHashMap<TimeUnit,Long>();
    long milliesRest = diffInMillies;
    for ( TimeUnit unit : units ) {
        long diff = unit.convert(milliesRest,TimeUnit.MILLISECONDS);
        long diffInMilliesForUnit = unit.toMillis(diff);
        milliesRest = milliesRest - diffInMilliesForUnit;
        result.put(unit,diff);
    }
    return result;
}

Http://ideone.com/5dXeu6

Wyjście jest czymś w rodzaju Map:{DAYS=1, HOURS=3, MINUTES=46, SECONDS=40, MILLISECONDS=0, MICROSECONDS=0, NANOSECONDS=0}, z uporządkowanymi jednostkami.

Wystarczy przekonwertować tę mapę na przyjazną dla użytkownika sznurek.

Ostrzeżenie

Powyższe fragmenty kodu obliczają proste różnice między 2 instancjami. Może powodować problemy podczas włączania światła dziennego, jak wyjaśniono w ten post. Oznacza to, że jeśli obliczysz różnicę między datami bez czasu, możesz mieć brakujący dzień / godzinę.

Moim zdaniem różnica daty jest subiektywna, szczególnie w dniach. Możesz:

• Policz ile czasu upłynęło 24h: dzień+1-dzień = 1 dzień = 24h

• Policz ilość czasu, który upłynął, dbając o czas letni: dzień+1-dzień = 1 = 24h (ale używając czasu północy i czasu letniego może to być 0 dzień i 23h)

• Policz liczbę day switches, co oznacza dzień+1 1pm - dzień 11am = 1 dzień, nawet jeśli upłynął tylko 2h (lub 1h jeśli jest czas letni :p)

Moja odpowiedź jest ważna, jeśli twoja definicja daty w dniach pasuje do 1. Przypadku

Z JodaTime

Jeśli używasz JodaTime można uzyskać diff dla 2 instants (millies wspierane ReadableInstant) daty z:

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

Ale możesz również uzyskać diff dla lokalnych dat/godzin:

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

Zauważ, że działa to z datami UTC, więc różnica może być dniem wolnym, jeśli spojrzysz na daty lokalne. A doprowadzenie go do poprawnego działania z lokalnymi datami wymaga zupełnie innego podejścia ze względu na czas letni.

Musisz jaśniej zdefiniować swój problem. Można po prostu wziąć liczbę milisekund między dwoma obiektami {[0] } i podzielić przez liczbę milisekund w ciągu 24 godzin, na przykład... ale:

• to nie uwzględnia stref czasowych - Date jest zawsze w UTC
• to nie będzie brane pod uwagę czas letni (gdzie mogą być dni, które trwają tylko 23 godziny, na przykład)
• nawet w UTC, ile dni jest w sierpniu 16.11.09 do 18.08.09? To tylko 27 godzin, więc czy to oznacza jeden dzień? A może trzy dni, bo obejmuje trzy daty?

Za pomocą Javy.czas framework wbudowany w Javę 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());

Wyjście:

ISO-8601: PT24H10M

Minut: 1450

Aby uzyskać więcej informacji, zobacz Oracle Tutorial i ISO 8601 standard.

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

Http://joda-time.sourceforge.net/faq.html#datediff

Tl;dr

Konwersja przestarzałych java.util.Date obiektów na ich zamiennik, java.time.Instant. Następnie oblicz czas, jaki upłynął jako 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

Format ISO 8601: PnYnMnDTnHnMnS

Przykłady:

• P3Y6M4DT12H30M5S
  trzy lata, sześć miesięcy, cztery dni, dwanaście godzin, trzydzieści minut i pięć sekund [70]}
• PT4H30M
  cztery i pół godziny

Java.czas

Java.time framework wbudowany w Javę 8 i późniejsze wypiera kłopotliwe stare java.util.Date/java.util.Calendar klasy. Nowe klasy są inspirowane wysoce udanym frameworkiem Joda-Time {61]}, który ma być jego następcą, podobnym w koncepcji, ale ponownie zaprojektowanym. Zdefiniowane przez JSR 310. Rozszerzony o projekt ThreeTen-Extra. Zobacz Tutorial .

Moment

The Instant Klasa reprezentuje moment na osi czasu w UTC z rozdzielczością nanosekund (do dziewięciu (9) cyfry ułamka dziesiętnego).

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

Najlepiej unikać klas starszych, takich jak Date/Calendar. Ale jeśli musisz współpracować ze starym kodem, który nie został jeszcze zaktualizowany do java.czas , konwertować tam iz powrotem. Wywołuje nowe metody konwersji dodane do starych klas. Do przenoszenia z java.util.Date na Instant, call Date::toInstant.

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

Span of time

Java.klasy czasu podzieliły tę ideę przedstawiania przedziału czasu jako liczby z lat, miesięcy, Dni, Godzin, Minut, Sekund na dwie połówki:

• Period dla lat, miesięcy, dni
• Duration dla Dni, Godzin, Minut, Sekund

Oto przykład.

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

Zrzut do konsoli.

Zarówno Period jak i Duration używają ISO 8601 do generowania reprezentacji łańcuchowej ich wartości.

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

Teraz: 2015-11-26t00:46:48.016-05:00[Ameryka/Montreal] do przyszłości: 2015-11-26t00: 46: 48.016-05: 00[Ameryka/Montreal] = PT1H3M

Java 9 dodaje metody do Duration, aby uzyskać część dni, część godzin, część minut i część sekund.

Możesz uzyskać całkowitą liczbę Dni, Godzin, Minut, Sekund, milisekund lub nanosekund w całym czasie trwania.

long totalHours = duration.toHours();

W Javie 9Duration Klasa otrzymuje nowe metody do zwracania różnych części Dni, Godzin, Minut, Sekund, milisekund/nanosekund. Call the to…Part metody: toDaysPart(), toHoursPart(), i tak dalej.

ChronoUnit

Jeśli zależy Ci tylko na prostszej większej ziarnistości czasu, takiej jak "liczba dni, które upłynęły", użyj ChronoUnit enum.

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

Kolejny przykład.

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

120

O Javie.czas

Java.Framework time jest wbudowany w Javę 8 i nowszą. Klasy te zastępują kłopotliwe stare dziedzictwo klasy date-time, takie jak java.util.Date, Calendar, & SimpleDateFormat.

Projekt Joda-Time , obecnie w trybie konserwacji , radzi migrację do Javy.czas.

Skąd pobrać Javę.zajęcia czasowe?

• Java SE 8 oraz SE 9 i Później
  • Wbudowany.
  • część standardowego API Javy z dołączoną implementacją.
  • Java 9 dodaje kilka drobnych funkcji i poprawek.
• Java SE 6 oraz SE 7
  • Większość Javy.funkcja czasu powraca-przeportowana do Javy 6 i 7 w ThreeTen-Backport.
• Android
  • The ThreeTenABP projekt dostosowuje ThreeTen-Backport (wymienione powyżej) specjalnie dla Androida.
  • Zobacz jak używać....

ProjektThreeTen-Extra rozszerza Javę.czas z dodatkowymi zajęciami. Ten projekt jest poligonem dla potencjalnych przyszłych dodatków do Javy.czas. Możesz znaleźć tutaj kilka przydatnych klas, takich jak Interval, YearWeek, YearQuarter, i więcej.

Joda-Czas

Aktualizacja: projekt Joda-Time jest teraz w trybie konserwacji , a zespół radzi migrację do java.czas klasy. Zostawiam tę sekcję nietkniętą dla historii.

Biblioteka Joda-Time używa ISO 8601 dla swoich domyślnych wartości. Jej klasa Period parsuje i generuje łańcuchy 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 );

Renders:

period: PT4H30M

Nieco prostsza alternatywa:

System.currentTimeMillis() - oldDate.getTime()

Co do "ładniejszego": cóż, czego dokładnie potrzebujesz? Problem z przedstawieniem czasu trwania jako liczby godzin i dni itp. czy może to prowadzić do nieścisłości i błędnych oczekiwań ze względu na złożoność dat (np. dni mogą mieć 23 lub 25 godzin ze względu na czas letni).

Użycie podejścia milisekundowego może powodować problemy w niektórych lokalizacjach.

Weźmy na przykład różnicę między dwoma datami 03/24/2007 i 03/25/2007 powinna wynosić 1 dzień;

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

Lepszym sposobem na zaimplementowanie tego jest użycie Javy.util.Kalendarz

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

Istnieje wiele sposobów, aby znaleźć różnicę między datami i godzinami. Jednym z najprostszych sposobów jakie znam to:

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

Instrukcja print jest tylko przykładem-możesz ją formatować, tak jak chcesz.

Ponieważ wszystkie odpowiedzi są poprawne, ale używaj legacy java lub 3rd party libs jak joda lub podobne, po prostu rzucę inny sposób używając nowej java.klasy time w Javie 8 i nowszych. Zobacz Oracle Tutorial .

Użycie LocalDate oraz 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 );

Odejmowanie dat w milisekundach działa (jak opisano w innym poście) , ale musisz używać HOUR_OF_DAY, a nie HOUR przy czyszczeniu części czasowych dat:

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
}

Spójrz na Joda Time , który jest ulepszonym API daty/czasu dla Javy i powinien działać dobrze ze scalą.

Jeśli nie chcesz używać JodaTime lub podobnego, najlepszym rozwiązaniem jest prawdopodobnie to:

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

Liczba ms dziennie nie zawsze jest taka sama (ze względu na czas letni i sekundy przestępne), ale jest bardzo blisko, a przynajmniej odchylenia spowodowane czasem letnim anulują się w dłuższych okresach. Dlatego dzielenie, a następnie zaokrąglanie da poprawny wynik (przynajmniej tak długo, jak używany kalendarz lokalny nie zawiera dziwnych skoków czasu innych niż DST i skok sekund).

Należy pamiętać, że nadal zakłada się, że date1 i date2 są ustawione na tę samą porę dnia. Dla różnych porach dnia najpierw musisz określić, co oznacza "różnica dat", jak zauważył Jon Skeet.

Pozwól mi pokazać różnicę między interwałem Jody a dniami:

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 

Jeśli potrzebujesz sformatowanego ciągu zwrotnego jak "2 dni 03h 42m 07S", spróbuj tego:

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

Sprawdź przykład tutaj http://www.roseindia.net/java/beginners/DateDifferent.shtml Ten przykład daje różnicę w dniach, godzinach, minutach, sekundach i milisekundach :).

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

Użyj strefy czasowej GMT aby uzyskać instancję kalendarza, ustaw czas za pomocą metody set klasy kalendarza. Strefa czasowa GMT ma przesunięcie 0 (niezbyt ważne) i flagę czasu letniego ustawioną na 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));

Następujący kod może dać pożądany wynik:

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;

Najlepszą rzeczą do zrobienia jest

(Date1-Date2)/86 400 000 

Liczba ta jest liczbą milisekund w ciągu dnia.

Jedna Data-inna data daje różnicę w milisekundach.

Zbierz odpowiedź w zmiennej double .

Jest to prawdopodobnie najprostszy sposób, aby to zrobić - być może dlatego, że koduję w Javie (z jej wprawdzie niezgrabnymi bibliotekami daty i czasu) od jakiegoś czasu, ale ten kod wygląda "prosto i ładnie" dla mnie!

Czy jesteś zadowolony z tego, że wynik jest zwracany w milisekundach, czy częścią twojego pytania jest to, że wolałbyś, aby został zwrócony w jakimś alternatywnym formacie?

Nie używając standardowego API, Nie. Sam możesz sobie zrobić coś takiego:

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

Lub możesz użyć Joda :

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

Uwaga: startdate i EndDate to - > java.util.Data

import org.joda.time.Duration;
import org.joda.time.Interval;
Interval interval = new Interval(startDate.getTime(), endDate.getTime);
Duration period = interval.toDuration();
period.getStandardDays() //gives the number of days elapsed between start and end date

Podobnie jak dni, możesz również uzyskać godziny, minuty i sekundy

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

Aby odpowiedzieć na pierwsze pytanie:

Umieść następujący kod w funkcji takiej jak 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;

Najważniejsza jest praca z długimi liczbami podczas mnożenia i dzielenia. I oczywiście przesunięcie, które Java stosuje w swoim rachunku dat.

:)

Ponieważ pytanie jest oznaczone 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

Oto poprawne rozwiązanie Java 7 W O(1) bez żadnych zależności.

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

Spróbuj tego:

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

Możesz edytować łańcuch w metodach parse () param.

Ponieważ używasz Scali, istnieje bardzo dobra biblioteka Scali Lamma . Z Lamma można odjąć datę bezpośrednio za pomocą operatora -

scala> Date(2015, 5, 5) - 2     // minus days by int
res1: io.lamma.Date = Date(2015,5,3)

scala> Date(2015, 5, 15) - Date(2015, 5, 8)   // minus two days => difference between two days
res2: Int = 7