¿Cómo obtener la hora de inicio y finalización de un día?

código como este no es exacto:

 private Date getStartOfDay(Date date) {
    Calendar calendar = Calendar.getInstance();
    int year = calendar.get(Calendar.YEAR);
    int month = calendar.get(Calendar.MONTH);
    int day = calendar.get(Calendar.DATE);
    calendar.set(year, month, day, 0, 0, 0);
    return calendar.getTime();
}

private Date getEndOfDay(Date date) {
    Calendar calendar = Calendar.getInstance();
    int year = calendar.get(Calendar.YEAR);
    int month = calendar.get(Calendar.MONTH);
    int day = calendar.get(Calendar.DATE);
    calendar.set(year, month, day, 23, 59, 59);
    return calendar.getTime();
}

No tiene una precisión de milisegundos.

tl; dr

LocalDate                       // Represents an entire day, without time-of-day and without time zone.
.now(                           // Capture the current date.
    ZoneId.of( "Asia/Tokyo" )   // Returns a `ZoneId` object.
)                               // Returns a `LocalDate` object.
.atStartOfDay(                  // Determines the first moment of the day as seen on that date in that time zone. Not all days start at 00:00!
    ZoneId.of( "Asia/Tokyo" ) 
)                               // Returns a `ZonedDateTime` object.

Inicio del día

Obtenga la longitud completa de hoy como se ve en una zona horaria.

Utilizando el enfoque Half-Open, donde el principio es inclusivo mientras que el final es exclusivo . Este enfoque resuelve la falla en su código que no tiene en cuenta el último segundo del día.

ZoneId zoneId = ZoneId.of( "Africa/Tunis" ) ;
LocalDate today = LocalDate.now( zoneId  ) ;

ZonedDateTime zdtStart = today.atStartOfDay( zoneId ) ;
ZonedDateTime zdtStop = today.plusDays( 1 ).atStartOfDay( zoneId ) ;

zdtStart.toString () = 2020-01-30T00: 00 + 01: 00 [África / Túnez]

zdtStop.toString () = 2020-01-31T00: 00 + 01: 00 [África / Túnez]

Ver los mismos momentos en UTC.

Instant start = zdtStart.toInstant() ;
Instant stop = zdtStop.toInstant() ;

start.toString () = 2020-01-29T23: 00: 00Z

stop.toString () = 2020-01-30T23: 00: 00Z

Si desea el día completo de una fecha como se ve en UTC en lugar de en una zona horaria, use OffsetDateTime.

LocalDate today = LocalDate.now( ZoneOffset.UTC  ) ;

OffsetDateTime odtStart = today.atTime( OffsetTime.MIN ) ;
OffsetDateTime odtStop = today.plusDays( 1 ).atTime( OffsetTime.MIN ) ;

odtStart.toString () = 2020-01-30T00: 00 + 18: 00

odtStop.toString () = 2020-01-31T00: 00 + 18: 00

Estos OffsetDateTime objetos ya estarán en UTC, pero puede llamar toInstantsi los necesita, que siempre están en UTC por definición.

Instant start = odtStart.toInstant() ;
Instant stop = odtStop.toInstant() ;

start.toString () = 2020-01-29T06: 00: 00Z

stop.toString () = 2020-01-30T06: 00: 00Z

Sugerencia: Puede que le interese agregar la biblioteca ThreeTen-Extra a su proyecto para usar su Intervalclase para representar este par de Instantobjetos. Esto ofrece la clase métodos útiles para la comparación como abuts, overlaps, contains, y mucho más.

Interval interval = Interval.of( start , stop ) ;

interval.toString () = 2020-01-29T06: 00: 00Z / 2020-01-30T06: 00: 00Z

Medio abierto

La respuesta de mprivat es correcta. Su punto es no tratar de obtener el final del día, sino compararlo con "antes del comienzo del día siguiente". Su idea se conoce como el enfoque "Half-Open" donde un lapso de tiempo tiene un comienzo que es inclusivo mientras que el final es exclusivo .

• Los marcos actuales de fecha y hora de Java (java.util.Date/Calendar y Joda-Time ) usan milisegundos de la época . Pero en Java 8, las nuevas clases java.time. * JSR 310 utilizan una resolución de nanosegundos. Cualquier código que haya escrito basado en forzar la cuenta de milisegundos del último momento del día sería incorrecto si se cambiara a las nuevas clases.
• La comparación de datos de otras fuentes se vuelve defectuosa si emplean otras resoluciones. Por ejemplo, las bibliotecas de Unix suelen emplear segundos enteros y las bases de datos como Postgres resuelven la fecha y la hora en microsegundos.
• Algunos cambios en el horario de verano ocurren durante la medianoche, lo que podría confundir aún más las cosas.

Joda-Time 2.3 ofrece un método para este mismo propósito, para obtener un primer momento del día: withTimeAtStartOfDay(). Del mismo modo, en java.time, LocalDate::atStartOfDay.

Busque en StackOverflow "joda medio abierto" para ver más debates y ejemplos.

Vea esta publicación, Los intervalos de tiempo y otros rangos deben estar medio abiertos , por Bill Schneider.

Evite las clases de fecha y hora heredadas

Las clases java.util.Date y .Calendar son notoriamente problemáticas. Evítales.

Utilice clases de java.time . El marco java.time es el sucesor oficial de la exitosa biblioteca Joda-Time .

java.time

El marco java.time está integrado en Java 8 y versiones posteriores. Adaptado a Java 6 y 7 en el proyecto ThreeTen-Backport , más adaptado a Android en el proyecto ThreeTenABP .

Un Instantes un momento en la línea de tiempo en UTC con una resolución de nanosegundos .

Instant instant = Instant.now();

Aplique una zona horaria para obtener la hora del reloj de pared de alguna localidad.

ZoneId zoneId = ZoneId.of( "America/Montreal" );
ZonedDateTime zdt = ZonedDateTime.ofInstant( instant , zoneId );

Para obtener el primer momento del día, repase la LocalDateclase y su atStartOfDaymétodo.

ZonedDateTime zdtStart = zdt.toLocalDate().atStartOfDay( zoneId );

Usando el enfoque Half-Open, obtenga el primer momento del día siguiente.

ZonedDateTime zdtTomorrowStart = zdtStart.plusDays( 1 );

Actualmente, el marco java.time carece de una Intervalclase como se describe a continuación para Joda-Time. Sin embargo, el proyecto ThreeTen-Extra extiende java.time con clases adicionales. Este proyecto es el campo de pruebas para posibles adiciones futuras a java.time. Entre sus clases se encuentra Interval. Construye un Intervalpasando un par de Instantobjetos. Podemos extraer un Instantde nuestros ZonedDateTimeobjetos.

Interval today = Interval.of( zdtStart.toInstant() , zdtTomorrowStart.toInstant() );

Acerca de 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.

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 .

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

Puede intercambiar objetos java.time directamente con su base de datos. Utilice un controlador JDBC compatible con JDBC 4.2 o posterior. No se necesitan cuerdas, no se necesitan java.sql.*clases. Hibernate 5 y JPA 2.2 admiten java.time .

¿Dónde obtener las clases java.time?

• Java SE 8 , Java SE 9 , Java SE 10 , Java SE 11 y posterior: parte de la API de Java estándar con una implementación integrada.
  • Java 9 trajo algunas características y correcciones menores.
• Java SE 6 y Java SE 7
  • La mayor parte de la funcionalidad de java.time se actualiza a Java 6 y 7 en ThreeTen-Backport .
• Androide
  • Las versiones posteriores de Android (26+) incluyen implementaciones de las clases java.time .
  • Para Android anterior (<26), un proceso conocido como API desugaring trae un subconjunto de la funcionalidad java.time que no estaba originalmente integrada en Android.
    • Si el desugaring no ofrece lo que necesita, el ThreeTenABP proyecto se adapta ThreeTen-Backport (mencionado anteriormente) para Android. Consulte Cómo utilizar ThreeTenABP… .

Joda-Time

ACTUALIZACIÓN: El proyecto Joda-Time ahora está en modo de mantenimiento y recomienda la migración a las clases java.time . Dejo esta sección intacta para la historia.

Joda-Time tiene tres clases para representar un espacio de tiempo de varias maneras: Interval, Period, y Duration. An Intervaltiene un comienzo y un final específicos en la línea de tiempo del Universo. Esto se ajusta a nuestra necesidad de representar "un día".

Llamamos al método en withTimeAtStartOfDaylugar de establecer la hora del día en ceros. Debido al horario de verano y otras anomalías, el primer momento del día puede no serlo 00:00:00.

Código de ejemplo usando Joda-Time 2.3.

DateTimeZone timeZone = DateTimeZone.forID( "America/Montreal" );
DateTime now = DateTime.now( timeZone );
DateTime todayStart = now.withTimeAtStartOfDay();
DateTime tomorrowStart = now.plusDays( 1 ).withTimeAtStartOfDay();
Interval today = new Interval( todayStart, tomorrowStart );

Si es necesario, puede convertirlo a java.util.Date.

java.util.Date date = todayStart.toDate();

Java 8

public static Date atStartOfDay(Date date) {
    LocalDateTime localDateTime = dateToLocalDateTime(date);
    LocalDateTime startOfDay = localDateTime.with(LocalTime.MIN);
    return localDateTimeToDate(startOfDay);
}

public static Date atEndOfDay(Date date) {
    LocalDateTime localDateTime = dateToLocalDateTime(date);
    LocalDateTime endOfDay = localDateTime.with(LocalTime.MAX);
    return localDateTimeToDate(endOfDay);
}

private static LocalDateTime dateToLocalDateTime(Date date) {
    return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
}

private static Date localDateTimeToDate(LocalDateTime localDateTime) {
    return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
}

Actualización : he agregado estos 2 métodos a mis clases de utilidad de Java aquí

• DateUtils.atStartOfDay
• DateUtils.atEndOfDay

Está en el repositorio central de Maven en:

<dependency>
  <groupId>com.github.rkumsher</groupId>
  <artifactId>utils</artifactId>
  <version>1.3</version>
</dependency>

Java 7 y versiones anteriores

Con Apache Commons

public static Date atEndOfDay(Date date) {
    return DateUtils.addMilliseconds(DateUtils.ceiling(date, Calendar.DATE), -1);
}

public static Date atStartOfDay(Date date) {
    return DateUtils.truncate(date, Calendar.DATE);
}

Sin Apache Commons

public Date atEndOfDay(Date date) {
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(date);
    calendar.set(Calendar.HOUR_OF_DAY, 23);
    calendar.set(Calendar.MINUTE, 59);
    calendar.set(Calendar.SECOND, 59);
    calendar.set(Calendar.MILLISECOND, 999);
    return calendar.getTime();
}

public Date atStartOfDay(Date date) {
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(date);
    calendar.set(Calendar.HOUR_OF_DAY, 0);
    calendar.set(Calendar.MINUTE, 0);
    calendar.set(Calendar.SECOND, 0);
    calendar.set(Calendar.MILLISECOND, 0);
    return calendar.getTime();
}

en getEndOfDay, puede agregar:

calendar.set(Calendar.MILLISECOND, 999);

Aunque matemáticamente hablando, no puede especificar el final de un día más que diciendo que es "antes del comienzo del día siguiente".

Así que en lugar de decir if(date >= getStartOfDay(today) && date <= getEndOfDay(today)), debe decir: if(date >= getStartOfDay(today) && date < getStartOfDay(tomorrow)). Esa es una definición mucho más sólida (y no tiene que preocuparse por la precisión de milisegundos).

java.time

Usando el java.timemarco integrado en Java 8.

import java.time.LocalTime;
import java.time.LocalDateTime;

LocalDateTime now = LocalDateTime.now(); // 2015-11-19T19:42:19.224
// start of a day
now.with(LocalTime.MIN); // 2015-11-19T00:00
now.with(LocalTime.MIDNIGHT); // 2015-11-19T00:00
// end of a day
now.with(LocalTime.MAX); // 2015-11-19T23:59:59.999999999

Una forma adicional de encontrar el inicio del día con java8 java.time.ZonedDateTime en lugar de pasar LocalDateTimees simplemente truncar la entrada ZonedDateTime a DAYS:

zonedDateTimeInstance.truncatedTo( ChronoUnit.DAYS );

Para java 8, las siguientes declaraciones de una sola línea están funcionando. En este ejemplo utilizo la zona horaria UTC. Considere cambiar la zona horaria que utiliza actualmente.

System.out.println(new Date());

final LocalDateTime endOfDay       = LocalDateTime.of(LocalDate.now(), LocalTime.MAX);
final Date          endOfDayAsDate = Date.from(endOfDay.toInstant(ZoneOffset.UTC));

System.out.println(endOfDayAsDate);

final LocalDateTime startOfDay       = LocalDateTime.of(LocalDate.now(), LocalTime.MIN);
final Date          startOfDayAsDate = Date.from(startOfDay.toInstant(ZoneOffset.UTC));

System.out.println(startOfDayAsDate);

Si no hay diferencia horaria con la salida. Tratar:ZoneOffset.ofHours(0)

Java 8 o ThreeTenABP

ZonedDateTime

ZonedDateTime curDate = ZonedDateTime.now();

public ZonedDateTime startOfDay() {
    return curDate
    .toLocalDate()
    .atStartOfDay()
    .atZone(curDate.getZone())
    .withEarlierOffsetAtOverlap();
}

public ZonedDateTime endOfDay() {

    ZonedDateTime startOfTomorrow =
        curDate
        .toLocalDate()
        .plusDays(1)
        .atStartOfDay()
        .atZone(curDate.getZone())
        .withEarlierOffsetAtOverlap();

    return startOfTomorrow.minusSeconds(1);
}

// based on https://stackoverflow.com/a/29145886/1658268

LocalDateTime

LocalDateTime curDate = LocalDateTime.now();

public LocalDateTime startOfDay() {
    return curDate.atStartOfDay();
}

public LocalDateTime endOfDay() {
    return startOfTomorrow.atTime(LocalTime.MAX);  //23:59:59.999999999;
}

// based on https://stackoverflow.com/a/36408726/1658268

Espero que ayude a alguien.

¡Probé este código y funciona bien!

final ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
final ZonedDateTime startofDay =
    now.toLocalDate().atStartOfDay(ZoneOffset.UTC);
final ZonedDateTime endOfDay =
    now.toLocalDate().atTime(LocalTime.MAX).atZone(ZoneOffset.UTC);

Otra solución que no depende de ningún marco es:

static public Date getStartOfADay(Date day) {
    final long oneDayInMillis = 24 * 60 * 60 * 1000;
    return new Date(day.getTime() / oneDayInMillis * oneDayInMillis);
}

static public Date getEndOfADay(Date day) {
    final long oneDayInMillis = 24 * 60 * 60 * 1000;
    return new Date((day.getTime() / oneDayInMillis + 1) * oneDayInMillis - 1);
}

Tenga en cuenta que devuelve la hora basada en UTC

private Date getStartOfDay(Date date) {
    Calendar calendar = Calendar.getInstance();
    int year = calendar.get(Calendar.YEAR);
    int month = calendar.get(Calendar.MONTH);
    int day = calendar.get(Calendar.DATE);
    calendar.setTimeInMillis(0);
    calendar.set(year, month, day, 0, 0, 0);
    return calendar.getTime();
    }

private Date getEndOfDay(Date date) {
    Calendar calendar = Calendar.getInstance();
    int year = calendar.get(Calendar.YEAR);
    int month = calendar.get(Calendar.MONTH);
    int day = calendar.get(Calendar.DATE);
    calendar.setTimeInMillis(0);
    calendar.set(year, month, day, 23, 59, 59);
    return calendar.getTime();
    }

calendar.setTimeInMillis (0); le da una precisión de hasta milisegundos

Sé que es un poco tarde, pero en el caso de Java 8, si está usando OffsetDateTime (que ofrece muchas ventajas, como TimeZone, Nanoseconds, etc.), puede usar el siguiente código:

OffsetDateTime reallyEndOfDay = someDay.withHour(23).withMinute(59).withSecond(59).withNano(999999999);
// output: 2019-01-10T23:59:59.999999999Z

Tuve varios inconvenientes con todas las soluciones porque necesitaba el tipo de variable Instant y la Zona horaria siempre interfería cambiando todo, luego combinando soluciones vi que esta es una buena opción.

        LocalDate today = LocalDate.now();
        Instant startDate = Instant.parse(today.toString()+"T00:00:00Z");
        Instant endDate = Instant.parse(today.toString()+"T23:59:59Z");

y tenemos como resultado

        startDate = 2020-01-30T00:00:00Z
        endDate = 2020-01-30T23:59:59Z

Espero que te ayude

Creo que lo más fácil sería algo como:

// Joda Time

DateTime dateTime=new DateTime(); 

StartOfDayMillis = dateTime.withMillis(System.currentTimeMillis()).withTimeAtStartOfDay().getMillis();
EndOfDayMillis = dateTime.withMillis(StartOfDayMillis).plusDays(1).minusSeconds(1).getMillis();

Estos milis se pueden convertir en Calendar, Instant o LocalDate según sus requisitos con Joda Time.

public static Date beginOfDay(Date date) {
    Calendar cal = Calendar.getInstance();
    cal.setTime(date);
    cal.set(Calendar.HOUR_OF_DAY, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    cal.set(Calendar.MILLISECOND, 0);

    return cal.getTime();
}

public static Date endOfDay(Date date) {
    Calendar cal = Calendar.getInstance();
    cal.setTime(date);
    cal.set(Calendar.HOUR_OF_DAY, 23);
    cal.set(Calendar.MINUTE, 59);
    cal.set(Calendar.SECOND, 59);
    cal.set(Calendar.MILLISECOND, 999);

    return cal.getTime();
}