Como obter a hora de início e a hora de término de um dia?

código como este não é preciso:

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

Não é preciso até o milissegundo.

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.

Início do dia

Obtenha o comprimento total do hoje como visto em um fuso horário.

Utilizando a abordagem semi-aberta, onde o início é inclusivo e o final é exclusivo . Essa abordagem resolve a falha no seu código que falha em explicar o último segundo do dia.

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 / Tunis]

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

Veja os mesmos momentos no UTC.

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

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

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

Se você deseja o dia inteiro de uma data como visto no UTC, e não no fuso horário, 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

Esses OffsetDateTime objetos já estarão no UTC, mas você pode chamar toInstantse precisar desses objetos que estão sempre no UTC, por definição.

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

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

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

Dica: você pode estar interessado em adicionar a biblioteca ThreeTen-Extra ao seu projeto para usar sua Intervalclasse para representar esse par de Instantobjetos. Isto oferece classe métodos úteis para comparação, como abuts, overlaps, containse muito mais.

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

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

Meio aberto

A resposta do mprivat está correta. Seu argumento é não tentar obter o final de um dia, mas comparar com "antes do início do dia seguinte". Sua idéia é conhecida como a abordagem "semi-aberta", em que um período de tempo tem um começo inclusivo, enquanto o final é exclusivo .

• As estruturas atuais de data e hora do Java (java.util.Date/Calendar e Joda-Time ) usam milissegundos da época . Mas no Java 8, as novas classes JSR 310 java.time. * Usam resolução de nanossegundos. Qualquer código que você escreveu com base na imposição da contagem de milissegundos do último momento do dia estaria incorreto se alternado para as novas classes.
• A comparação de dados de outras fontes se torna defeituosa se empregar outras resoluções. Por exemplo, as bibliotecas Unix normalmente empregam segundos inteiros, e bancos de dados como o Postgres resolvem a data e hora em microssegundos.
• Algumas alterações no horário de verão acontecem à meia-noite, o que pode confundir ainda mais as coisas.

Joda-Time 2.3 oferece um método para este mesmo fim, para obter primeiro momento do dia: withTimeAtStartOfDay(). Da mesma forma em java.time LocalDate::atStartOfDay,.

Pesquise StackOverflow por "joda half-open" para ver mais discussões e exemplos.

Veja este post, Intervalos de tempo e outros intervalos devem estar semi-abertos , por Bill Schneider.

Evite classes de data e hora herdadas

As classes java.util.Date e .Calendar são notoriamente problemáticas. Evite-os.

Use as classes java.time . A estrutura java.time é o sucessor oficial da bem - sucedida biblioteca Joda-Time .

java.time

A estrutura java.time é integrada ao Java 8 e posterior. Portado para Java 6 e 7 no projeto ThreeTen-Backport , adaptado ao Android no projeto ThreeTenABP .

An Instanté um momento na linha do tempo no UTC com uma resolução de nanossegundos .

Instant instant = Instant.now();

Aplique um fuso horário para obter a hora do relógio de parede em alguma localidade.

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

Para obter o primeiro momento do dia, leia a LocalDateaula e seu atStartOfDaymétodo.

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

Usando a abordagem semi-aberta, obtenha o primeiro momento do dia seguinte.

ZonedDateTime zdtTomorrowStart = zdtStart.plusDays( 1 );

Atualmente, a estrutura java.time não possui uma Intervalclasse, conforme descrito abaixo para o Joda-Time. No entanto, o projeto ThreeTen-Extra estende o java.time com classes adicionais. Este projeto é o campo de prova para possíveis adições futuras ao java.time. Entre suas classes é Interval. Construa um Intervalpassando um par de Instantobjetos. Podemos extrair um Instantde nossos ZonedDateTimeobjetos.

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

Sobre java.time

A estrutura java.time é integrada ao Java 8 e posterior. Essas classes suplantar os velhos problemáticos legados aulas de data e hora, como java.util.Date, Calendar, e SimpleDateFormat.

Para saber mais, consulte o Tutorial do Oracle . E procure Stack Overflow para muitos exemplos e explicações. A especificação é JSR 310 .

O projeto Joda-Time , agora em modo de manutenção , aconselha a migração para as classes java.time .

Você pode trocar objetos java.time diretamente com seu banco de dados. Use um driver JDBC compatível com JDBC 4.2 ou posterior. Não há necessidade de strings, não há necessidade de java.sql.*classes. O Hibernate 5 e o JPA 2.2 suportam java.time .

Onde obter as classes java.time?

• Java SE 8 , Java SE 9 , Java SE 10 , Java SE 11 e posterior - Parte da API Java padrão com uma implementação em pacote configurável.
  • O Java 9 trouxe alguns recursos e correções menores.
• Java SE 6 e Java SE 7
  • A maior parte da funcionalidade java.time é portada para Java 6 e 7 no ThreeTen-Backport .
• Android
  • Versões posteriores do Android (26+) empacotam implementações das classes java.time .
  • Para Android anterior (<26), um processo conhecido como desugaring de API traz um subconjunto da funcionalidade java.time não originalmente incorporada no Android.
    • Se o Dessacarificação não oferece o que você precisa, o ThreeTenABP projeto adapta ThreeTen-Backport (mencionados acima) para Android. Consulte Como usar o ThreeTenABP… .

Joda-Time

ATUALIZAÇÃO: O projeto Joda-Time agora está no modo de manutenção e aconselha a migração para as classes java.time . Estou deixando esta seção intacta para a história.

Joda-Time tem três classes para representar um espaço de tempo de várias maneiras: Interval, Period, e Duration. Um Intervaltem um começo e um fim específicos na linha do tempo do Universo. Isso se encaixa em nossa necessidade de representar "um dia".

Chamamos o método em withTimeAtStartOfDayvez de definir a hora do dia como zeros. Por causa do horário de verão e de outras anomalias, o primeiro momento do dia pode não ser 00:00:00.

Exemplo de código usando o 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 );

Se necessário, você pode converter para um 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());
}

Atualização : Adicionei estes 2 métodos às minhas Java Utility Classes aqui

• DateUtils.atStartOfDay
• DateUtils.atEndOfDay

Está no Repositório Central do Maven em:

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

Java 7 e anteriores

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

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

em getEndOfDay, você pode adicionar:

calendar.set(Calendar.MILLISECOND, 999);

Embora matematicamente falando, você não pode especificar o final de um dia a não ser dizendo que é "antes do início do dia seguinte".

Então, em vez de dizer, if(date >= getStartOfDay(today) && date <= getEndOfDay(today))você deve dizer: if(date >= getStartOfDay(today) && date < getStartOfDay(tomorrow)). Essa é uma definição muito mais sólida (e você não precisa se preocupar com precisão de milissegundos).

java.time

Usando a java.timeestrutura incorporada no 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

Uma maneira adicional de encontrar o início do dia com java8 java.time.ZonedDateTime em vez de passar LocalDateTimeé simplesmente truncar a entrada ZonedDateTime para DAYS:

zonedDateTimeInstance.truncatedTo( ChronoUnit.DAYS );

Para java 8, as seguintes instruções de linha única estão funcionando. Neste exemplo, eu uso o fuso horário UTC. Por favor, considere alterar o TimeZone usado atualmente.

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

Se não houver diferença horária com a saída. Experimentar:ZoneOffset.ofHours(0)

Java 8 ou 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 ajude alguém.

Eu tentei esse código e funciona bem!

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

Outra solução que não depende de nenhuma estrutura é:

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

Observe que ele retorna o horário com base no 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); fornece precisão de até milissegundos

Sei que é um pouco tarde, mas no caso do Java 8, se você estiver usando o OffsetDateTime (que oferece muitas vantagens, como TimeZone, Nanossegundos etc.), você pode usar o seguinte código:

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

Tive vários inconvenientes com todas as soluções, porque precisava do tipo de variável Instant e o fuso horário sempre interferia na mudança de tudo. Depois, combinando soluções, vi que essa é uma boa opção.

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

e nós temos como resultado

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

Espero que ajude você

Eu acho que o mais fácil seria algo como:

// Joda Time

DateTime dateTime=new DateTime(); 

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

Esses milis podem ser convertidos em Calendário, Instant ou LocalDate conforme sua necessidade com o 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();
}