Calculando a diferença entre duas instâncias de data Java

Estou usando a class java.util.Date do Java no Scala e quero comparar um object Date e a hora atual. Eu sei que posso calcular o delta usando getTime ():

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

No entanto, isso só me deixa com uma long milissegundos representando. Existe alguma maneira mais simples e agradável de obter um tempo delta?

A API de Date JDK está terrivelmente quebrada, infelizmente. Eu recomendo usar a biblioteca Joda Time .

Joda Time tem um conceito de intervalo de tempo:

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

EDIT: By the way, Joda tem dois conceitos: Interval para representar um intervalo de tempo entre dois instantes de tempo (representam o tempo entre 8 e 10), e uma Duration que representa um período de tempo sem os limites de tempo reais (por exemplo, representam duas horas !)

Se você se importa apenas com comparações de tempo, a maioria das implementações de Date (incluindo a do JDK) implementa a interface Comparable , que permite que você use o Comparable.compareTo()

Diff simples (sem 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); } 

E então você pode ligar:

 getDateDiff(date1,date2,TimeUnit.MINUTES); 

para obter o diff das 2 datas em minutos.

TimeUnit é java.util.concurrent.TimeUnit , um enum Java padrão que vai de nanos a dias.


Diff humano legível (sem lib)

 public static Map computeDiff(Date date1, Date date2) { long diffInMillies = date2.getTime() - date1.getTime(); List units = new ArrayList(EnumSet.allOf(TimeUnit.class)); Collections.reverse(units); Map result = new LinkedHashMap(); 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

A saída é algo como Map:{DAYS=1, HOURS=3, MINUTES=46, SECONDS=40, MILLISECONDS=0, MICROSECONDS=0, NANOSECONDS=0} , com as unidades solicitadas.

Você só precisa converter esse mapa em uma string amigável.


Atenção

Os trechos de código acima calculam um diff simples entre 2 instantes. Isso pode causar problemas durante um horário de verão, como explicado neste post . Isto significa que se você calcular o diff entre as datas sem tempo, você pode ter um dia / hora ausente.

Na minha opinião a data diff é meio subjetiva, principalmente nos dias. Você pode:

  • contar o número de 24 horas decorridas: dia + 1 dia = 1 dia = 24 horas

  • conte o número de tempo decorrido, tomando conta do horário de verão: dia + 1 dia = 1 = 24h (mas usando o tempo da meia-noite e o horário de verão, pode ser 0 dia e 23h)

  • contar o número de day switches de day switches , o que significa dia + 1 1pm – dia 11am = 1 dia, mesmo que o tempo decorrido seja de apenas 2h (ou 1h se houver um horário de verão: p)

Minha resposta é válida se a sua definição de data diff nos dias coincidir com o primeiro caso

Com JodaTime

Se você estiver usando o JodaTime, você pode obter o diff por 2 instantes (millies suportados pelo ReadableInstant) com:

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

Mas você também pode obter o diff para datas / horários locais:

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

Observe que isso funciona com datas UTC, portanto, a diferença pode ser um dia de folga se você observar datas locais. E fazê-lo funcionar corretamente com datas locais requer uma abordagem completamente diferente devido ao horário de verão.

Você precisa definir seu problema com mais clareza. Você poderia simplesmente pegar o número de milissegundos entre os dois objects Date e dividir pelo número de milissegundos em 24 horas, por exemplo … mas:

  • Isso não levará em consideração os fusos horários – a Date é sempre em UTC
  • Isso não levará em consideração o horário de verão (onde pode haver dias com apenas 23 horas de duração, por exemplo)
  • Mesmo dentro da UTC, quantos dias tem entre 16 e 23 de agosto até 18 de agosto? São apenas 27 horas, então isso significa um dia? Ou deveria ser três dias porque abrange três datas?

Usando o framework java.time incorporado no 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()); 

Saída:

ISO-8601: PT24H10M

Minutos: 1450

Para mais informações, consulte o Oracle Tutorial e o padrão ISO 8601 .

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

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

tl; dr

Converta seus objects java.util.Date obsoletos em sua substituição, java.time.Instant . Em seguida, calcule o tempo decorrido como 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.toMinutos (): 154

d.toMinutesPart (): 34

Formato ISO 8601: PnYnMnDTnHnMnS

O padrão sensato ISO 8601 define uma representação textual concisa de um período de tempo como um número de anos, meses, dias, horas, etc. O padrão chama tal extensão por uma duração . O formato é PnYnMnDTnHnMnS que P significa “Período”, o T separa a parte da data da parte do tempo e entre eles são os números seguidos por uma letra.

Exemplos:

  • P3Y6M4DT12H30M5S
    três anos, seis meses, quatro dias, doze horas, trinta minutos e cinco segundos
  • PT4H30M
    Quatro horas e meia

java.time

O framework java.time embutido no Java 8 e posterior suplanta as problemáticas classs java.util.Calendar / java.util.Calendar . As novas classs são inspiradas pelo altamente bem – sucedido framework Joda-Time , concebido como seu sucessor, similar em conceito, mas reprojetado. Definido pelo JSR 310 . Estendido pelo projeto ThreeTen-Extra . Veja o tutorial .

Momento

A class Instant representa um momento na linha do tempo no UTC com uma resolução de nanossegundos (até nove (9) dígitos de uma fração decimal).

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

Melhor evitar as classs legadas, como Date / Calendar . Mas se você precisar interoperar com código antigo ainda não atualizado para java.time , converta para frente e para trás. Chame os novos methods de conversão adicionados às classs antigas. Para mover de um java.util.Date para um Instant , chame Date::toInstant .

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

Período de tempo

As classs java.time dividiram essa ideia de representar um período de tempo como um número de anos, meses, dias, horas, minutos, segundos em duas metades:

  • Period para anos, meses, dias
  • Duration para dias, horas, minutos, segundos

Aqui está um exemplo.

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

Despeje para consolar.

Tanto Period quanto Duration usam o padrão ISO 8601 para gerar uma representação de String de seu valor.

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

agora: 2015-11-26T00: 46: 48.016-05: 00 [América / Montreal] para o futuro: 2015-11-26T00: 46: 48.016-05: 00 [América / Montreal] = PT1H3M

O Java 9 adiciona methods à Duration para obter os dias parte, horas parte, minutos parte e segundos parte.

Você pode obter o número total de dias ou horas, minutos ou segundos, ou milissegundos ou nanossegundos em toda a duração.

 long totalHours = duration.toHours(); 

No Java 9, a class Duration obtém novos methods para retornar as várias partes de dias, horas, minutos, segundos, milissegundos / nanossegundos. Chame o to…Part Métodos de to…Part : toDaysPart() , toHoursPart() e assim por diante.

ChronoUnit

Se você se importa apenas com uma granularidade maior e mais simples, como “número de dias decorridos”, use o enum ChronoUnit .

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

Outro exemplo.

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

120


Sobre o java.time

O framework java.time está embutido no Java 8 e posterior. Essas classs substituem as antigas classs herdadas de data e hora legadas , como java.util.Date , Calendar e SimpleDateFormat .

O projeto Joda-Time , agora em modo de manutenção , aconselha a migration para java.time.

Para saber mais, veja o Oracle Tutorial . E pesquise o Stack Overflow para muitos exemplos e explicações. A especificação é JSR 310 .

Onde obter as classs java.time?

  • Java SE 8 e SE 9 e posterior
    • Construídas em.
    • Parte da API Java padrão com uma implementação integrada.
    • O Java 9 adiciona alguns resources e correções menores.
  • Java SE 6 e SE 7
    • Grande parte da funcionalidade java.time é transferida para o Java 6 e 7 no ThreeTen-Backport .
  • Android
    • O projeto ThreeTenABP adapta o ThreeTen-Backport (mencionado acima) especificamente para o Android.
    • Veja como usar… .

O projeto ThreeTen-Extra estende java.time com classs adicionais. Este projeto é um campo de testes para possíveis futuras adições ao java.time. Você pode encontrar algumas classs úteis aqui como Interval , YearWeek , YearQuarter e muito mais .


Joda-Time

ATUALIZAÇÃO: O projeto Joda-Time está agora no modo de manutenção , com a equipe recomendando a migration para as classs java.time . Deixo esta seção intacta para a história.

A biblioteca Joda-Time usa o ISO 8601 para seus padrões. Sua class de Period analisa e gera essas seqüências de caracteres 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 

Uma alternativa um pouco mais simples:

 System.currentTimeMillis() - oldDate.getTime() 

Quanto a “melhor”: bem, o que exatamente você precisa? O problema de representar a duração do tempo como um número de horas e dias etc. é que pode levar a imprecisões e expectativas erradas devido à complexidade das datas (por exemplo, os dias podem ter 23 ou 25 horas devido ao horário de verão).

Usar a abordagem de milissegundos pode causar problemas em algumas localidades.

Vamos considerar, por exemplo, que a diferença entre as duas datas 24/03/2007 e 25/03/2007 deve ser de 1 dia;

No entanto, usando a rota milissegundo, você receberá 0 dias, se você executar isso no Reino Unido!

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

Melhor maneira de implementar isso é usar 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; } 

Há muitas maneiras de encontrar a diferença entre datas e horas. Uma das maneiras mais simples que conheço seria:

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

A declaração de impressão é apenas um exemplo – você pode formatá-la da maneira que preferir.

Como todas as respostas aqui estão corretas, mas use Java legado ou bibliotecas de terceiros, como joda ou similar, eu vou simplesmente usar outra class java.time no Java 8 e posterior. Veja o Oracle Tutorial .

Use LocalDate e 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 ); 

Subtrair as datas em milissegundos funciona (conforme descrito em outro post), mas você precisa usar HOUR_OF_DAY e não HOUR ao limpar as partes do tempo de suas datas:

 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 } 

Dê uma olhada no Joda Time , que é uma API de Data / Hora aprimorada para Java e deve funcionar bem com o Scala.

Se você não quiser usar JodaTime ou similar, a melhor solução é provavelmente esta:

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

O número de ms por dia nem sempre é o mesmo (devido ao horário de verão e aos segundos bissextos), mas é muito próximo e, pelo menos, os desvios devido ao horário de verão são cancelados por períodos mais longos. Portanto, a divisão e o arredondamento darão um resultado correto (pelo menos enquanto o calendar local usado não contiver saltos de tempo estranhos além do DST e dos segundos de salto).

Observe que isso ainda pressupõe que date1 e date2 estejam definidos para a mesma hora do dia. Para diferentes momentos do dia, você primeiro tem que definir o que “diferença de data” significa, como apontado por Jon Skeet.

Deixe-me mostrar a diferença entre Joda Interval e Days:

 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 

Se você precisar de uma string de retorno formatada como “2 dias 03h 42m 07s”, tente o seguinte:

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

Veja o exemplo aqui http://www.roseindia.net/java/beginners/DateDifferent.shtml Este exemplo dá-lhe a diferença em dias, horas, minutos, segundos e milésimos :).

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

Use o fuso horário GMT para obter uma instância do Calendário, defina a hora usando o método set da class Calendar. O fuso horário GMT tem 0 deslocamento (não muito importante) e o sinalizador de horário de verão definido como falso.

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

O código a seguir pode fornecer a saída desejada:

 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; 

Best thing to do is

 (Date1-Date2)/86 400 000 

That number is the number of milliseconds in a day.

One date-other date gives you difference in milliseconds.

Collect the answer in a double variable.

That’s probably the most straightforward way to do it – perhaps it’s because I’ve been coding in Java (with its admittedly clunky date and time libraries) for a while now, but that code looks “simple and nice” to me!

Are you happy with the result being returned in milliseconds, or is part of your question that you would prefer to have it returned in some alternative format?

Not using the standard API, no. You can roll your own doing something like this:

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

Or you can use Joda :

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

Note: startDate and endDates are -> java.util.Date

 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 

Similar to days, you can also get hours, minutes and seconds

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

Just to answer the initial question:

Put the following code in a Function like 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; 

The most important here is to work with long numbers when multiplying and dividing. And of course, the offset that Java applies in its calculus of Dates.

🙂

Here’s a correct Java 7 solution in O(1) without any dependencies.

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

try this:

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

you can edit the string in the parse() methods param.

Since you are using Scala, there is a very good Scala library Lamma . With Lamma you can minus date directly with - operator

 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 

Just use below method with two Date objects. If you want to pass current date, just pass new Date() as a second parameter as it is initialised with current time.

 public String getDateDiffString(Date dateOne, Date dateTwo) { long timeOne = dateOne.getTime(); long timeTwo = dateTwo.getTime(); long oneDay = 1000 * 60 * 60 * 24; long delta = (timeTwo - timeOne) / oneDay; if (delta > 0) { return "dateTwo is " + delta + " days after dateOne"; } else { delta *= -1; return "dateTwo is " + delta + " days before dateOne"; } } 

Also, apart from from number of days, if, you want other parameter difference too, use below snippet,

 int year = delta / 365; int rest = delta % 365; int month = rest / 30; rest = rest % 30; int weeks = rest / 7; int days = rest % 7; 

PS Code is entirely taken from an SO answer.