¿Cómo encuentro la diferencia en días entre dos instancias de Joda-Time DateTime ? Con "diferencia en días" quiero decir que si el inicio es el lunes y el final es el martes, espero un valor de retorno de 1 independientemente de la hora / minuto / segundo de las fechas de inicio y finalización.

Days.daysBetween(start, end).getDays() me da 0 si el inicio es por la tarde y termina por la mañana.

También tengo el mismo problema con otros campos de fecha, así que esperaba que hubiera una forma genérica de "ignorar" los campos de menor importancia.

En otras palabras, los meses entre febrero y 4 de marzo también serían 1, al igual que las horas entre las 14:45 y las 15:12. Sin embargo, la diferencia horaria entre las 14:01 y las 14:55 sería 0.

Molesto, la respuesta withTimeAtStartOfDay es incorrecta, pero solo ocasionalmente. Usted quiere:

Days.daysBetween(start.toLocalDate(), end.toLocalDate()).getDays()

Resulta que "medianoche / comienzo del día" a veces significa 1 am (el horario de verano ocurre de esta manera en algunos lugares), que Days.daysBetween no se maneja correctamente.

// 5am on the 20th to 1pm on the 21st, October 2013, Brazil
DateTimeZone BRAZIL = DateTimeZone.forID("America/Sao_Paulo");
DateTime start = new DateTime(2013, 10, 20, 5, 0, 0, BRAZIL);
DateTime end = new DateTime(2013, 10, 21, 13, 0, 0, BRAZIL);
System.out.println(daysBetween(start.withTimeAtStartOfDay(),
                               end.withTimeAtStartOfDay()).getDays());
// prints 0
System.out.println(daysBetween(start.toLocalDate(),
                               end.toLocalDate()).getDays());
// prints 1

Yendo por un LocalDatelado elude todo el asunto.

Days Clase

Usar la Daysclase con el withTimeAtStartOfDaymétodo debería funcionar:

Days.daysBetween(start.withTimeAtStartOfDay() , end.withTimeAtStartOfDay() ).getDays() 

puedes usar LocalDate:

Days.daysBetween(new LocalDate(start), new LocalDate(end)).getDays() 

tl; dr

java.time.temporal.ChronoUnit.DAYS.between( 
    earlier.toLocalDate(), 
    later.toLocalDate() 
)

…o…

java.time.temporal.ChronoUnit.HOURS.between( 
    earlier.truncatedTo( ChronoUnit.HOURS )  , 
    later.truncatedTo( ChronoUnit.HOURS ) 
)

java.time

Para su información, el proyecto Joda-Time ahora está en modo de mantenimiento , y el equipo aconseja migrar a las clases java.time .

El equivalente de Joda-Time DateTimees ZonedDateTime.

ZoneId z = ZoneId.of( "Pacific/Auckland" ) ;
ZonedDateTime now = ZonedDateTime.now( z ) ;

Aparentemente desea contar los días por fechas, lo que significa que desea ignorar la hora del día. Por ejemplo, comenzar un minuto antes de la medianoche y terminar un minuto después de la medianoche debería dar como resultado un solo día. Para este comportamiento, extraiga un LocalDatede su ZonedDateTime. La LocalDateclase representa un valor de solo fecha sin hora del día y sin zona horaria.

LocalDate localDateStart = zdtStart.toLocalDate() ;
LocalDate localDateStop = zdtStop.toLocalDate() ;

Use la ChronoUnitenumeración para calcular los días transcurridos u otras unidades.

long days = ChronoUnit.DAYS.between( localDateStart , localDateStop ) ;

Truncar

En cuanto a preguntar por una forma más general de hacer este recuento cuando le interesa el delta de horas como la hora del reloj en lugar de las horas completas como un período de tiempo de sesenta minutos, use el truncatedTométodo.

Aquí está su ejemplo de 14:45 a 15:12 el mismo día.

ZoneId z = ZoneId.of( "America/Montreal" ); 
ZonedDateTime start = ZonedDateTime.of( 2017 , 1 , 17 , 14 , 45 , 0 , 0 , z );
ZonedDateTime stop = ZonedDateTime.of( 2017 , 1 , 17 , 15 , 12 , 0 , 0 , z );

long hours = ChronoUnit.HOURS.between( start.truncatedTo( ChronoUnit.HOURS ) , stop.truncatedTo( ChronoUnit.HOURS ) );

1

Esto no funciona por días. Use toLocalDate () en este caso.

Sobre java.time

El marco java.time está integrado en Java 8 y versiones posteriores. Estas clases suplantar la vieja problemáticos heredados clases de fecha y hora como java.util.Date, Calendar, y SimpleDateFormat.

El proyecto Joda-Time , ahora en modo de mantenimiento , aconseja la migración a las clases java.time .

Para obtener más información, consulte el Tutorial de Oracle . Y busque Stack Overflow para obtener muchos ejemplos y explicaciones. La especificación es JSR 310 .

Puede intercambiar objetos java.time directamente con su base de datos. Utilice un controlador JDBC compatible con JDBC 4.2 o posterior. No hay necesidad de cadenas, no hay necesidad de java.sql.*clases.

¿Dónde obtener las clases java.time?

• Java SE 8 , Java SE 9 , Java SE 10 y posterior
  • Incorporado.
  • Parte de la API Java estándar con una implementación integrada.
  • Java 9 agrega algunas características menores y correcciones.
• Java SE 6 y Java SE 7
  • Gran parte de la funcionalidad java.time se transfiere a Java 6 y 7 en ThreeTen-Backport .
• Androide
  • Versiones posteriores de las implementaciones de paquetes de Android de las clases java.time.
  • Para anteriormente Android (<26), el ThreeTenABP proyecto adapta ThreeTen-Backport (mencionado anteriormente). Ver Cómo utilizar ThreeTenABP ... .

El proyecto ThreeTen-Extra extiende java.time con clases adicionales. Este proyecto es un campo de pruebas para posibles adiciones futuras a java.time. Usted puede encontrar algunas clases útiles aquí, como Interval, YearWeek, YearQuarter, y más .

El proyecto ThreeTen-Extra extiende java.time con clases adicionales. Este proyecto es un campo de pruebas para posibles adiciones futuras a java.time. Usted puede encontrar algunas clases útiles aquí, como Interval, YearWeek, YearQuarter, y más .

La respuesta aceptada crea dos LocalDateobjetos, que son bastante caros si está leyendo muchos datos. Yo uso esto:

  public static int getDaysBetween(DateTime earlier, DateTime later)
  {
    return (int) TimeUnit.MILLISECONDS.toDays(later.getMillis()- earlier.getMillis());
  }

Al llamar getMillis(), utiliza variables ya existentes.
MILLISECONDS.toDays()luego, usa un cálculo aritmético simple, no crea ningún objeto.

java.time.Period

Usa la java.time.Periodclase para contar días .

Como Java 8 calcular la diferencia es más intuitivo LocalDate, LocalDateTimerepresenta las dos fechas

    LocalDate now = LocalDate.now();
    LocalDate inputDate = LocalDate.of(2018, 11, 28);

    Period period = Period.between( inputDate, now);
    int diff = period.getDays();
    System.out.println("diff = " + diff);

DateTime  dt  = new DateTime(laterDate);        

DateTime newDate = dt.minus( new  DateTime ( previousDate ).getMillis());

System.out.println("No of days : " + newDate.getDayOfYear() - 1 );    

public static int getDifferenceIndays(long timestamp1, long timestamp2) {
    final int SECONDS = 60;
    final int MINUTES = 60;
    final int HOURS = 24;
    final int MILLIES = 1000;
    long temp;
    if (timestamp1 < timestamp2) {
        temp = timestamp1;
        timestamp1 = timestamp2;
        timestamp2 = temp;
    }
    Calendar startDate = Calendar.getInstance(TimeZone.getDefault());
    Calendar endDate = Calendar.getInstance(TimeZone.getDefault());
    endDate.setTimeInMillis(timestamp1);
    startDate.setTimeInMillis(timestamp2);
    if ((timestamp1 - timestamp2) < 1 * HOURS * MINUTES * SECONDS * MILLIES) {
        int day1 = endDate.get(Calendar.DAY_OF_MONTH);
        int day2 = startDate.get(Calendar.DAY_OF_MONTH);
        if (day1 == day2) {
            return 0;
        } else {
            return 1;
        }
    }
    int diffDays = 0;
    startDate.add(Calendar.DAY_OF_MONTH, diffDays);
    while (startDate.before(endDate)) {
        startDate.add(Calendar.DAY_OF_MONTH, 1);
        diffDays++;
    }
    return diffDays;
}