Come ottenere l'ora di inizio e l'ora di fine di una giornata?

codice come questo non è accurato:

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

Non è preciso al millisecondo.

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.

Inizio della giornata

Ottieni l'intera durata della giornata odierna come si vede in un fuso orario.

Utilizzando l'approccio Half-Open, dove è l'inizio inclusivo mentre il finale è esclusivo . Questo approccio risolve il difetto nel codice che non riesce a tenere conto dell'ultimo secondo della giornata.

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 [Africa / Tunisi]

zdtStop.toString () = 2020-01-31T00: 00 + 01: 00 [Africa / Tunisi]

Guarda gli stessi momenti in UTC.

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

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

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

Se desideri visualizzare l'intero giorno di una data in UTC anziché in un fuso orario, utilizza 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

Questi OffsetDateTime oggetti saranno già in UTC, ma puoi chiamare toInstantse hai bisogno di tali oggetti che sono sempre in UTC per definizione.

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

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

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

Suggerimento: potresti essere interessato ad aggiungere la libreria ThreeTen-Extra al tuo progetto per utilizzare la sua Intervalclasse per rappresentare questa coppia di Instantoggetti. Questo offre classe metodi utili per il confronto, come abuts, overlaps, contains, e altro ancora.

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

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

Mezzo aperto

La risposta di mprivat è corretta. Il suo punto è non cercare di ottenere la fine di una giornata, ma piuttosto confrontarla con "prima dell'inizio del giorno successivo". La sua idea è nota come approccio "semiaperto" in cui un arco di tempo ha un inizio inclusivo mentre il finale è esclusivo .

• Gli attuali framework data-ora di Java (java.util.Date/Calendar e Joda-Time ) utilizzano entrambi i millisecondi dell'epoca . Ma in Java 8, le nuove classi java.time. * JSR 310 utilizzano una risoluzione in nanosecondi. Qualsiasi codice scritto in base alla forzatura del conteggio dei millisecondi dell'ultimo momento della giornata non sarebbe corretto se passato alle nuove classi.
• Il confronto dei dati da altre fonti diventa errato se utilizzano altre risoluzioni. Ad esempio, le librerie Unix in genere impiegano interi secondi e database come Postgres risolvono la data e l'ora in microsecondi.
• Alcuni cambiamenti dell'ora legale avvengono dopo mezzanotte, il che potrebbe confondere ulteriormente le cose.

Joda-Time 2.3 offre un metodo per questo scopo, per ottenere primo momento della giornata: withTimeAtStartOfDay(). Allo stesso modo in java.time,LocalDate::atStartOfDay .

Cerca in StackOverflow "joda half-open" per vedere ulteriori discussioni ed esempi.

Vedi questo post, Intervalli di tempo e altri intervalli dovrebbero essere semiaperti , di Bill Schneider.

Evita le classi data-ora precedenti

Le classi java.util.Date e .Calendar sono notoriamente problematiche. Evitali.

Usa le classi java.time . Il framework java.time è il successore ufficiale della libreria di grande successo Joda-Time .

java.time

Il framework java.time è integrato in Java 8 e versioni successive. Backport su Java 6 e 7 nel progetto ThreeTen-Backport , ulteriormente adattato ad Android nel ThreeTenABP progetto .

Un Instantè un momento sulla timeline in UTC con una risoluzione di nanosecondi .

Instant instant = Instant.now();

Applica un fuso orario per ottenere l' ora dell'orologio da parete per alcune località.

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

Per ottenere il primo momento della giornata, ripassa la LocalDatelezione e il suo atStartOfDaymetodo.

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

Usando l'approccio Half-Open, ottieni il primo momento del giorno successivo.

ZonedDateTime zdtTomorrowStart = zdtStart.plusDays( 1 );

Attualmente il framework java.time manca di una Intervalclasse come descritto di seguito per Joda-Time. Tuttavia, il progetto ThreeTen-Extra estende java.time con classi aggiuntive. Questo progetto è il banco di prova per possibili future aggiunte a java.time. Tra le sue classi c'è Interval. Costruisci un Intervalpassando un paio di Instantoggetti. Possiamo estrarre un Instantdai nostri ZonedDateTimeoggetti.

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

Informazioni su java.time

Il framework java.time è integrato in Java 8 e versioni successive. Queste classi soppiantare la vecchia fastidiosi legacy classi data-time come java.util.Date, Calendar, e SimpleDateFormat.

Per saperne di più, vedere il tutorial Oracle . E cerca Stack Overflow per molti esempi e spiegazioni. La specifica è JSR 310 .

Il progetto Joda-Time , ora in modalità di manutenzione , consiglia la migrazione alle classi java.time .

Puoi scambiare oggetti java.time direttamente con il tuo database. Utilizza un driver JDBC compatibile con JDBC 4.2 o successivo. Non c'è bisogno di stringhe, non c'è bisogno di java.sql.*classi. Hibernate 5 e JPA 2.2 supportano java.time .

Dove ottenere le classi java.time?

• Java SE 8 , Java SE 9 , Java SE 10 , Java SE 11 e versioni successive: parte dell'API Java standard con un'implementazione in bundle.
  • Java 9 ha apportato alcune funzionalità e correzioni minori.
• Java SE 6 e Java SE 7
  • La maggior parte delle funzionalità java.time è sottoposta a back port su Java 6 e 7 in ThreeTen-Backport .
• androide
  • Le versioni successive di Android (26+) raggruppano le implementazioni delle classi java.time .
  • Per le versioni precedenti di Android (<26), un processo noto come API desugaring porta un sottoinsieme della funzionalità java.time non originariamente incorporata in Android.
    • Se il Dezuccheraggio non offre quello che ti serve, il ThreeTenABP progetto si adatta ThreeTen-Backport (di cui sopra) per Android. Vedi Come usare ThreeTenABP… .

Joda-Time

AGGIORNAMENTO: Il progetto Joda-Time è ora in modalità di manutenzione e consiglia la migrazione alle classi java.time . Lascio questa sezione intatta per la storia.

Joda Time ha tre classi per rappresentare un arco di tempo in vari modi: Interval, Period, e Duration. An Intervalha un inizio e una fine specifici sulla linea temporale dell'Universo. Ciò corrisponde alla nostra esigenza di rappresentare "un giorno".

Chiamiamo il metodo withTimeAtStartOfDaypiuttosto che impostare l'ora del giorno su zero. A causa dell'ora legale e di altre anomalie, il primo momento della giornata potrebbe non esserlo 00:00:00.

Codice di esempio utilizzando 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 è necessario, è possibile convertire in 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());
}

Aggiornamento : ho aggiunto questi 2 metodi alle mie classi di utilità Java qui

• DateUtils.atStartOfDay
• DateUtils.atEndOfDay

Si trova nel Maven Central Repository all'indirizzo:

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

Java 7 e versioni precedenti

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

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

in getEndOfDay, puoi aggiungere:

calendar.set(Calendar.MILLISECOND, 999);

Sebbene matematicamente parlando, non è possibile specificare la fine di un giorno se non dicendo che è "prima dell'inizio del giorno successivo".

Così, invece di dire, if(date >= getStartOfDay(today) && date <= getEndOfDay(today))si dovrebbe dire: if(date >= getStartOfDay(today) && date < getStartOfDay(tomorrow)). Questa è una definizione molto più solida (e non devi preoccuparti della precisione del millisecondo).

java.time

Utilizzo del java.timeframework integrato in 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

Un altro modo per trovare l'inizio della giornata con java8 java.time.ZonedDateTime invece di passare attraverso LocalDateTimeè semplicemente troncare l'input ZonedDateTime a DAYS:

zonedDateTimeInstance.truncatedTo( ChronoUnit.DAYS );

Per java 8 funzionano le seguenti istruzioni a riga singola. In questo esempio utilizzo il fuso orario UTC. Considera la possibilità di modificare il fuso orario attualmente utilizzato.

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 nessuna differenza di orario con l'uscita. Provare: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

Spero che aiuti qualcuno.

Ho provato questo codice e funziona bene!

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

Un'altra soluzione che non dipende da alcun framework è:

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

Notare che restituisce l'ora basata su 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); ti dà una precisione fino a millisecondi

So che è un po 'tardi, ma nel caso di Java 8, se stai usando OffsetDateTime (che offre molti vantaggi, come TimeZone, Nanoseconds, ecc.), Puoi usare il seguente codice:

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

Ho avuto diversi inconvenienti con tutte le soluzioni perché avevo bisogno del tipo di variabile Istantanea e il fuso orario interferiva sempre cambiando tutto, quindi combinando le soluzioni ho visto che questa è una buona opzione.

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

e abbiamo come risultato

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

Spero ti aiuti

Penso che il più semplice sarebbe qualcosa del tipo:

// Joda Time

DateTime dateTime=new DateTime(); 

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

Questi millisecondi possono essere quindi convertiti in Calendar, Instant o LocalDate secondo le tue esigenze 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();
}