Java, calcola il numero di giorni tra due date

Possibile duplicato:
Calcolo della differenza tra due istanze di data Java

In Java, voglio calcolare il numero di giorni tra due date.

Nel mio database sono archiviati come datatype DATE , ma nel mio codice sono stringhe.

Voglio calcolare il no dei giorni tra quelle due stringhe.

Beh, per cominciare, dovresti trattare con loro come stringhe quando devi. La maggior parte delle volte dovresti lavorare con loro in un tipo di dati che descrive effettivamente i dati con cui stai lavorando.

Ti consiglio di utilizzare Joda Time , che è un’API molto migliore di Date / Calendar . Sembra che dovresti usare il tipo LocalDate in questo caso. Puoi quindi utilizzare:

 int days = Days.daysBetween(date1, date2).getDays(); 

prova questo codice

  Calendar cal1 = new GregorianCalendar(); Calendar cal2 = new GregorianCalendar(); SimpleDateFormat sdf = new SimpleDateFormat("ddMMyyyy"); Date date = sdf.parse("your first date"); cal1.setTime(date) date = sdf.parse("your second date"); cal2.setTime(date); //cal1.set(2008, 8, 1); //cal2.set(2008, 9, 31); System.out.println("Days= "+daysBetween(cal1.getTime(),cal2.getTime())); 

questa funzione

  public int daysBetween(Date d1, Date d2){ return (int)( (d2.getTime() - d1.getTime()) / (1000 * 60 * 60 * 24)); } 

In Java 8. È ansible utilizzare istanze di Enum ChronoUnit per calcolare la quantità di tempo in unità diverse (giorni, mesi, secondi).

Per esempio:

 ChronoUnit.DAYS.between(startDate,endDate) 

So che questo thread ha due anni ora, non vedo ancora una risposta corretta qui.

A meno che non si desideri utilizzare Joda o Java 8 e se è necessario eseguire la registrazione delle date influenzate dall’ora legale.

Quindi ho scritto la mia soluzione. L’aspetto importante è che funziona solo se ti interessano solo le date perché è necessario eliminare le informazioni sull’ora, quindi se desideri qualcosa come 25.06.2014 - 01.01.2010 = 1636 , questo dovrebbe funzionare indipendentemente dall’ora legale:

 private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd.MM.yyyy"); public static long getDayCount(String start, String end) { long diff = -1; try { Date dateStart = simpleDateFormat.parse(start); Date dateEnd = simpleDateFormat.parse(end); //time is always 00:00:00 so rounding should help to ignore the missing hour when going from winter to summer time as well as the extra hour in the other direction diff = Math.round((dateEnd.getTime() - dateStart.getTime()) / (double) 86400000); } catch (Exception e) { //handle the exception according to your own situation } return diff; } 

Poiché l’ora è sempre 00:00:00 , l’utilizzo di double e Math.round() dovrebbe aiutare a ignorare i 60000 ms mancanti (1 ora) quando si passa dall’inverno all’ora estiva e l’ora in più se si passa dall’estate all’inverno .

Questo è un piccolo test JUnit4 che uso per dimostrarlo:

 @Test public void testGetDayCount() { String startDateStr = "01.01.2010"; GregorianCalendar gc = new GregorianCalendar(locale); try { gc.setTime(simpleDateFormat.parse(startDateStr)); } catch (Exception e) { } for (long i = 0; i < 10000; i++) { String dateStr = simpleDateFormat.format(gc.getTime()); long dayCount = getDayCount(startDateStr, dateStr); assertEquals("dayCount must be equal to the loop index i: ", i, dayCount); gc.add(GregorianCalendar.DAY_OF_YEAR, 1); } } 

... o se vuoi vedere cosa fa 'vita', sostituisci l'asserzione con:

 System.out.println("i: " + i + " | " + dayCount + " - getDayCount(" + startDateStr + ", " + dateStr + ")"); 

... e questo è come dovrebbe apparire l'output:

  i: 0 | 0 - getDayCount(01.01.2010, 01.01.2010) i: 1 | 1 - getDayCount(01.01.2010, 02.01.2010) i: 2 | 2 - getDayCount(01.01.2010, 03.01.2010) i: 3 | 3 - getDayCount(01.01.2010, 04.01.2010) ... i: 1636 | 1636 - getDayCount(01.01.2010, 25.06.2014) ... i: 9997 | 9997 - getDayCount(01.01.2010, 16.05.2037) i: 9998 | 9998 - getDayCount(01.01.2010, 17.05.2037) i: 9999 | 9999 - getDayCount(01.01.2010, 18.05.2037) 

ecco un piccolo programma che può aiutarti:

 import java.util.*; public class DateDifference { public static void main(String args[]){ DateDifference difference = new DateDifference(); } DateDifference() { Calendar cal1 = new GregorianCalendar(); Calendar cal2 = new GregorianCalendar(); cal1.set(2010, 12, 1); cal2.set(2011, 9, 31); System.out.println("Days= "+daysBetween(cal1.getTime(),cal2.getTime())); } public int daysBetween(Date d1, Date d2) { return (int)( (d2.getTime() - d1.getTime()) / (1000 * 60 * 60 * 24)); } } 
 // http://en.wikipedia.org/wiki/Julian_day public static int julianDay(int year, int month, int day) { int a = (14 - month) / 12; int y = year + 4800 - a; int m = month + 12 * a - 3; int jdn = day + (153 * m + 2)/5 + 365*y + y/4 - y/100 + y/400 - 32045; return jdn; } public static int diff(int y1, int m1, int d1, int y2, int m2, int d2) { return julianDay(y1, m1, d1) - julianDay(y2, m2, d2); } 

Sono davvero davvero DAVVERO nuovo in Java, quindi sono sicuro che c’è un modo ancora migliore per fare ciò che sto proponendo.

Ho avuto questa stessa richiesta e l’ho fatto usando la differenza tra il DAYOFYEAR delle due date. Sembrava un modo più semplice per farlo …

Non posso davvero valutare questa soluzione in termini di prestazioni e stabilità, ma penso che sia ok.

Qui:

     public static void main (String [] args) genera ParseException {



 // Ho fatto questa parte del codice solo per creare le variabili che userò.
 // Sono in Brasile e il formato della data qui è GG / MM / AAAA, ma non sarà un problema per voi ragazzi. 
 // Funzionerà comunque con il tuo formato.

     String s1 = "18/09/2014"; 
     String s2 = "01/01/2014";
     DateFormat f = DateFormat.getDateInstance ();
     Data data1 = f.parse (s1); 
     Data data2 = f.parse (s2);




 // Ecco la parte in cui riceviamo i giorni tra due date.

     Calendar day1 = Calendar.getInstance ();
     Calendar day2 = Calendar.getInstance (); 
     day1.setTime (date1);
     day2.setTime (data2);

     int daysBetween = day1.get (Calendar.DAY_OF_YEAR) - day2.get (Calendar.DAY_OF_YEAR);      




 // Qualche codice solo per mostrare il risultato ...
     f = DateFormat.getDateInstance (DateFormat.MEDIUM);
     System.out.println ("C'è" + giorni tra + "giorni tra" + f.format (day1.getTime ()) + "e" + f.format (day2.getTime ()) + ".");



     }

In questo caso, l’output sarebbe (ricordando che sto usando il formato data DD / MM / YYYY):

 Ci sono 260 giorni tra il 18/09/2014 e il 01/01/2014.

Questa funzione va bene per me:

 public static int getDaysCount(Date begin, Date end) { Calendar start = org.apache.commons.lang.time.DateUtils.toCalendar(begin); start.set(Calendar.MILLISECOND, 0); start.set(Calendar.SECOND, 0); start.set(Calendar.MINUTE, 0); start.set(Calendar.HOUR_OF_DAY, 0); Calendar finish = org.apache.commons.lang.time.DateUtils.toCalendar(end); finish.set(Calendar.MILLISECOND, 999); finish.set(Calendar.SECOND, 59); finish.set(Calendar.MINUTE, 59); finish.set(Calendar.HOUR_OF_DAY, 23); long delta = finish.getTimeInMillis() - start.getTimeInMillis(); return (int) Math.ceil(delta / (1000.0 * 60 * 60 * 24)); } 

La mia soluzione migliore (finora) per calcolare il numero di giorni di differenza:

 // This assumes that you already have two Date objects: startDate, endDate // Also, that you want to ignore any time portions Calendar startCale=new GregorianCalendar(); Calendar endCal=new GregorianCalendar(); startCal.setTime(startDate); endCal.setTime(endDate); endCal.add(Calendar.YEAR,-startCal.get(Calendar.YEAR)); endCal.add(Calendar.MONTH,-startCal.get(Calendar.Month)); endCal.add(Calendar.DATE,-startCal.get(Calendar.DATE)); int daysDifference=endCal.get(Calendar.DAY_OF_YEAR); 

Si noti, tuttavia, che ciò presuppone meno di una differenza di un anno!

Se sei stufo di scherzare con java puoi semplicemente inviarlo a db2 come parte della tua query:

 select date1, date2, days(date1) - days(date2) from table 

restituirà date1, date2 e la differenza tra i due giorni.