Java, calcolare il numero di giorni tra due date

Question

Eventuali duplicati:
Calculating the Difference Between Two Java Date Instances

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

Nel mio database sono archiviati come un tipo di dati DATE, ma nel mio codice sono stringhe.

Voglio calcolare il no di giorni tra quelle due stringhe.

Answer 1

Bene per iniziare, è necessario solo trattare con loro come stringhe quando è necessario. La maggior parte delle volte dovresti lavorare con loro in un tipo di dati che descrive effettivamente i dati con cui stai lavorando.

Si consiglia di utilizzare Joda Time, che è un'API molto migliore di Date/Calendar. Sembra che dovresti usare il tipo LocalDate in questo caso. È quindi possibile utilizzare:

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

Answer 2

ecco un piccolo programma che può aiutare a:

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

Answer 3

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

Answer 4

Se si' sono stufo di scherzare con java che puoi solo vedere ND a DB2 come parte della vostra query:

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

tornerà data1, data2 e la differenza in giorni tra i due.

Answer 5

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

Answer 6

La mia soluzione migliore (finora) per il calcolo del numero di giorni 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 questo presuppone meno di differenza un anno!

Answer 7

Questa funzione è un 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)); 
} 

Answer 8

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

Per esempio:

ChronoUnit.DAYS.between(startDate,endDate) 

Answer 9

So che questa discussione è di due anni ormai, io ancora non vedo una risposta corretta qui.

A meno che non si desideri utilizzare Joda o Java 8 e se è necessario eseguire le date in base all'ora legale.

Quindi ho scritto la mia soluzione. L'aspetto importante è che funziona solo se si ha realmente a cuore solo di date perché è necessario eliminare le informazioni sul tempo, quindi se volete qualcosa di simile 25.06.2014 - 01.01.2010 = 1636, questo dovrebbe funzionare indipendentemente dalla DST:

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é il tempo è sempre 00:00:00, usando il doppio e poi Math.round() dovrebbe aiutare a ignorare i 60000ms mancanti (1 ora) quando si passa dall'inverno all'ora legale e l'ora in più se si passa dall'estate all'inverno.

Questo è un piccolo test JUnit4 Io lo 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 volete vedere quello che fa 'la vita', sostituire l'affermazione con un semplice:

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

... e questo è ciò che l'uscita dovrebbe essere simile:

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) 

Answer 10

sono davvero davvero davvero nuovo in Java, quindi sono sicuro che ci sia un n modo migliore per fare ciò che sto proponendo.

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

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

qui:

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



//Made this part of the code just to create the variables i'll use. 
//I'm in Brazil and the date format here is DD/MM/YYYY, but wont be an issue to you guys. 
//It will work anyway with your format. 

    String s1 = "18/09/2014"; 
    String s2 = "01/01/2014"; 
    DateFormat f = DateFormat.getDateInstance(); 
    Date date1 = f.parse(s1); 
    Date date2 = f.parse(s2); 




//Here's the part where we get the days between two dates. 

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

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




//Some code just to show the result... 
    f = DateFormat.getDateInstance(DateFormat.MEDIUM); 
    System.out.println("There's " + daysBetween + " days between " + f.format(day1.getTime()) + " and " + f.format(day2.getTime()) + "."); 



    } 

In questo caso, l'uscita sarebbe (ricordando che sto usando il DD Formato data/MM/AAAA):

 
There's 260 days between 18/09/2014 and 01/01/2014.