Java, calcular el número de días entre dos fechas

Question

Duplicar posibles:
Calculating the Difference Between Two Java Date Instances

En Java, quiero calcular el número de días entre dos fechas.

En mi base de datos se almacenan como un tipo de datos DATE, pero en mi código son cadenas.

Quiero calcular el número de días entre esas dos cadenas.

Answer 1

Bueno, para empezar, debe solo tratar con ellos como cadenas cuando sea necesario. La mayoría de las veces debe trabajar con ellos en un tipo de datos que realmente describa los datos con los que está trabajando.

Yo recomendaría que use Joda Time, que es una API mucho mejor que Date/Calendar. Parece que debería usar el tipo LocalDate en este caso. A continuación, puede utilizar:

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

Answer 2

aquí es un pequeño programa que puede ayudarle 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

prueba este código

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

esta función

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

Answer 4

Si' Estoy harto de jugar con Java, puedes simplemente ver nd a DB2 como parte de su consulta:

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

volverá fecha1, la fecha 2 y la diferencia en días entre los dos.

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

Mi mejor solución (hasta ahora) para calcular el número de días de diferencia:

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

Tenga en cuenta, sin embargo, que esto supone menos de un año de diferencia!

Answer 7

Esta función es bueno para mí:

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

En Java 8. Usted puede utilizar instancias de Enum ChronoUnit para calcular la cantidad de tiempo en diferentes unidades (días, meses, segundos).

Por ejemplo:

ChronoUnit.DAYS.between(startDate,endDate) 

Answer 9

Sé que este hilo es de dos años ahora, todavía no veo una respuesta correcta.

A menos que desee utilizar Joda o tener Java 8 y si necesita restar fechas influenciadas por el horario de verano.

Así que he escrito mi propia solución. El aspecto importante es que sólo funciona si realmente sólo se preocupan por las fechas porque es necesario desechar la información de tiempo, así que si quieres algo así como 25.06.2014 - 01.01.2010 = 1636, esto debería funcionar independientemente del horario de verano:

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

A medida que el tiempo siempre es 00:00:00, usando doble y luego Math.round() debería ayudar a ignorar los 60000ms faltantes (1 hora) cuando se pasa del invierno al horario de verano, así como la hora extra si va de verano a invierno.

Esto es una pequeña prueba junit4 utilizo para probarlo:

@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 si desea ver lo que hace 'vida', reemplace la afirmación con sólo:

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

... y esto es lo que la salida debe ser similar:

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

estoy muy muy muy nuevo en Java, por lo que estoy seguro de que hay una n aún mejor manera de hacer lo que propongo.

Tuve esta misma demanda y lo hice usando la diferencia entre el DAYOFYEAR de las dos fechas. Parecía una forma más fácil de hacerlo ...

Realmente no puedo evaluar esta solución en términos de rendimiento y estabilidad, pero creo que está bien.

aquí:

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



    } 

En este caso, la salida sería (recordando que estoy usando el DD Formato de fecha/MM/AAAA):

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