простой diff (без 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);
}

и тогда вы можете позвонить:

getDateDiff(date1,date2,TimeUnit.MINUTES);

чтобы получить разницу из 2 дат в минутах единицы.

TimeUnit is java.util.concurrent.TimeUnit, стандартное перечисление Java, идущее от nanos до дней.

читаемый человеком diff (без 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

выход что-то вроде Map:{DAYS=1, HOURS=3, MINUTES=46, SECONDS=40, MILLISECONDS=0, MICROSECONDS=0, NANOSECONDS=0}, с заказанными единицами.

вы просто необходимо преобразовать эту карту в удобную для пользователя строку.

предупреждение

приведенные выше фрагменты кода вычисляют простое различие между 2 мгновениями. Это может вызвать проблемы во время перехода на летнее время, как описано в этот пост. Это означает, что если вы вычисляете разницу между датами без времени, у вас может быть отсутствующий день/час.

на мой взгляд, разница в дате субъективна, особенно в дни. Вы май:

• подсчитайте количество 24h прошедшего времени: День+1 - день = 1 день = 24h

• подсчитайте количество прошедшего времени, заботясь о дневной экономии: день+1-day = 1 = 24h (но с использованием полуночного времени и летнего времени это может быть 0 день и 23h)

• подсчитать количество day switches, что означает День+1 1pm-день 11am = 1 день, даже если прошедшее время составляет всего 2h (или 1h, если есть летнее время : p)

мой ответ действителен, если ваше определение даты diff по дням соответствует 1-му случаю

С JodaTime

если вы используете JodaTime, вы можете получить разницу за 2 момента (millies backed ReadableInstant) даты с:

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

но вы также можете получить разницу для местных дат/времени:

// returns 4 because of the leap year of 366 days
new Period(LocalDate.now(), LocalDate.now().plusDays(365*5), PeriodType.years()).getYears() 

// this time it returns 5
new Period(LocalDate.now(), LocalDate.now().plusDays(365*5+1), PeriodType.years()).getYears() 

// And you can also use these static methods
Years.yearsBetween(LocalDate.now(), LocalDate.now().plusDays(365*5)).getYears()

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

обратите внимание, что это работает с датами UTC, поэтому разница может быть выходной день, если вы посмотрите на местные даты. И чтобы он работал правильно с местными датами, требуется совершенно другой подход из-за летнего времени.

вам нужно более четко определить свою проблему. Вы может просто возьмите количество миллисекунд между двумя Date объекты и делим на количество миллисекунд в 24 часа, например... но:

• это не будет принимать во внимание часовые пояса - Date всегда в UTC
• это не будет принимать во внимание летнее время (где могут быть дни, которые только 23 часа, например)
• даже в UTC, сколько дней в август 16th 11pm до август 18th 2am? Всего 27 часов, значит, один день? Или это должно быть три дня, потому что он охватывает три даты?

С помощью java.время фреймворк, встроенный в 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

для получения дополнительной информации см. В Oracle Учебник и ISO 8601 стандартные.

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

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

tl; dr

преобразовать устаревшие 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.
    )
;

д'.метод toString(): PT2H34M56S

д'.toMinutes(): 154

д'.toMinutesPart(): 34

формат ISO 8601:PnYnMnDTnHnMnS

разумный стандарт ISO 8601 определяет краткое текстовое представление промежутка времени как количество лет, месяцев, дней, часов и т. д. Стандарт называет такой промежуток продолжительность. Формат PnYnMnDTnHnMnS здесь P означает "периода",T отделяет часть даты от части времени, а между ними находятся цифры, за которыми следует буква.

примеры:

• P3Y6M4DT12H30M5S
  три года, шесть месяцев, четыре дня, двенадцать часов, тридцать минут и пять секунд
• PT4H30M
  четыре с половиной часы

java.время

на java.время фреймворк, встроенный в Java 8 и позже вытесняет хлопотный старый java.util.Date/java.util.Calendar классы. Новые классы вдохновлены очень успешными Joda Времени framework, предназначенный в качестве его преемника, похожий по концепции,но перестроенный. Определяется JSR 310. Расширено ThreeTen-Extra. Увидеть учебник.

момент

на Instant класс представляет момент на временной шкале в UTC с разрешением наносекунд (до девяти (9) цифр десятичной дробью).

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

лучше избегать устаревших классов, таких как Date/Calendar. Но если вы должны взаимодействовать со старым кодом, еще не обновленным до java.время, конвертировать туда и обратно. Call new методы преобразования добавлены к старым классам. Для перехода от java.util.Date до Instant, называют Date::toInstant.

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

период времени

java.классы времени разделили эту идею представления промежутка времени как числа лет, месяцев, дней, часов, минут, секунд на две половины:--48-->

• 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 использовать ISO 8601 стандарт для генерации строкового представления их значения.

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

сейчас: 2015-11-26T00: 46: 48.016-05: 00[Америка / Монреаль] в будущее: 2015-11-26T00:46:48.016-05: 00[Америка/Монреаль] = PT1H3M

Java 9 добавляет методы в Duration чтобы дни части, части часов, минут и секунд.

вы можете получить общее количество дней или часов или минут или секунд или миллисекунд или наносекунд в течение всего времени.

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.время

на java.время framework встроен в Java 8 и более поздние версии. Эти классы вытесняют беспокойных старый наследие классы даты и времени, такие как java.util.Date, Calendar, & SimpleDateFormat.

на Joda Времени, теперь режим обслуживания, советует миграцию на java.время.

чтобы узнать больше, см. Oracle Tutorial. И search Stack Overflow для многих примеров и объяснений. Спецификация JSR 310.

где получите java.время занятий?

• Java SE 8 и SE 9 и позже
  • встроенный.
  • часть стандартного API Java со встроенной реализацией.
  • Java 9 добавляет некоторые незначительные функции и исправления.
• Java SE 6 и SE 7
  • большая часть java.функциональность времени обратно портирована на Java 6 & 7 в ThreeTen-Backport.
• Android
  • на ThreeTenABP проект приспосабливается ThreeTen-Backport (упомянуто выше) для Android конкретно.
  • посмотреть как использовать....

на ThreeTen-Extra проект расширяет java.время с дополнительными занятиями. Этот проект является испытательной площадкой для возможных будущих дополнений к java.время. Здесь вы можете найти полезные классы, такие как Interval, YearWeek, YearQuarter и больше.

Joda Времени

обновление: The Joda Времени сейчас режим обслуживания, с командой, консультирующей миграцию в java.время классы. Я оставляю этот раздел нетронутым для истории.

библиотека 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

несколько более простая альтернатива:

System.currentTimeMillis() - oldDate.getTime()

Что касается "приятнее": Ну, что именно вам нужно? Проблема с представлением продолжительности времени в виде количества часов и дней и т. д. это может привести к неточностям и неправильным ожиданиям из-за сложности дат (например, дни могут иметь 23 или 25 часов из-за летнего времени).

использование миллисекундного подхода может вызвать проблемы в некоторых местах.

давайте возьмем, например, разницу между двумя датами 03/24/2007 и 03/25/2007 должно быть 1 день;

однако, используя миллисекундный маршрут, вы получите 0 дней, если вы запустите это в Великобритании!

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

лучший способ реализовать это-использовать java.утиль.Календарь

/** 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.время классы в Java 8 и выше. См.В Oracle Учебник.

использовать LocalDate и ChronoUnit:

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

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

вычитание дат в миллисекундах работает (как описано в другом посте), но вы есть использовать HOUR_OF_DAY, а не час при очистке временных частей ваших дат:

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
}

посмотри Джода Времени, который является улучшенным API даты/времени для Java и должен отлично работать с Scala.

Если вы не хотите использовать 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 и leap считанные секунды.)

обратите внимание, что это все еще предполагает, что date1 и date2 устанавливаются в одно и то же время суток. Для разных времен суток вам сначала нужно определить, что означает" разница в дате", как указал Джон Скит.

позвольте мне показать разницу между интервалом Joda и днями:

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 дня 03нтехнические 42М 07с", попробуйте это:

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, чтобы получить экземпляр календаря, установите время с помощью метода set класса Calendar. Часовой пояс 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";
    }
}   

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

лучше всего -

(Date1-Date2)/86 400 000 

Это число является числом МС в день.

одна дата-другая дата дает вам разницу в миллисекундах.

соберите ответ в двойной переменной.

Это, вероятно, самый простой способ сделать это-возможно, это потому, что я кодирую на Java (с его, по общему признанию, неуклюжими библиотеками даты и времени) некоторое время, но этот код выглядит "простым и приятным" для меня!

вы довольны результатом, возвращаемым в миллисекундах, или часть вашего вопроса, Что вы предпочли бы, чтобы он был возвращен в каком-то альтернативном формате?

не используя стандартный API, нет. Вы можете свернуть свой собственный, делая что-то вроде этого:

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

или вы можете использовать Джода:

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

Примечание: startDate и endDates - > java.утиль.Дата

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

подобно дням, вы также можете получить часы, минуты и секунды

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

просто ответить на первоначальный вопрос:

поместите следующий код в функцию 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;

наиболее важным здесь является работа с длинными числами при умножении и делении. И, конечно же, смещение, которое Java применяет в своем исчислении дат.

:)

Так как вопрос помечен Scala,

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

вот правильное решение Java 7 в O (1) без каких-либо зависимостей.

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

попробуйте это:

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

вы можете редактировать строку в Parse () методы param.

поскольку вы используете Scala, есть очень хорошая библиотека Scala Ламма. С Lamma вы можете минус дата непосредственно с - оператор

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