Dans mon code, j'ai besoin de trouver toutes mes choses qui se sont passées aujourd'hui. J'ai donc besoin de comparer avec les dates d'aujourd'hui à 00h00 (minuit tôt ce matin) à 12h00 (minuit ce soir).

Je sais ...

Date today = new Date(); 

... me prend tout de suite. Et ...

Date beginning = new Date(0);

... me donne zéro heure le 1er janvier 1970. Mais quel est le moyen facile d'obtenir l'heure zéro aujourd'hui et l'heure zéro demain?

MISE À JOUR; Je l'ai fait, mais il y a sûrement un moyen plus simple?

Calendar calStart = new GregorianCalendar();
calStart.setTime(new Date());
calStart.set(Calendar.HOUR_OF_DAY, 0);
calStart.set(Calendar.MINUTE, 0);
calStart.set(Calendar.SECOND, 0);
calStart.set(Calendar.MILLISECOND, 0);
Date midnightYesterday = calStart.getTime();

Calendar calEnd = new GregorianCalendar();
calEnd.setTime(new Date());
calEnd.set(Calendar.DAY_OF_YEAR, calEnd.get(Calendar.DAY_OF_YEAR)+1);
calEnd.set(Calendar.HOUR_OF_DAY, 0);
calEnd.set(Calendar.MINUTE, 0);
calEnd.set(Calendar.SECOND, 0);
calEnd.set(Calendar.MILLISECOND, 0);
Date midnightTonight = calEnd.getTime();

java.util.Calendar

// today    
Calendar date = new GregorianCalendar();
// reset hour, minutes, seconds and millis
date.set(Calendar.HOUR_OF_DAY, 0);
date.set(Calendar.MINUTE, 0);
date.set(Calendar.SECOND, 0);
date.set(Calendar.MILLISECOND, 0);

// next day
date.add(Calendar.DAY_OF_MONTH, 1);

JDK 8 - java.time.LocalTime et java.time.LocalDate

LocalTime midnight = LocalTime.MIDNIGHT;
LocalDate today = LocalDate.now(ZoneId.of("Europe/Berlin"));
LocalDateTime todayMidnight = LocalDateTime.of(today, midnight);
LocalDateTime tomorrowMidnight = todayMidnight.plusDays(1);

Joda-Time

Si vous utilisez un JDK <8, je recommande Joda Time , car l'API est vraiment sympa:

DateTime date = new DateTime().toDateMidnight().toDateTime();
DateTime tomorrow = date.plusDays(1);

La version 2.3 de Joda Time DateMidnightétant obsolète , utilisez donc ceci:

DateTime today = new DateTime().withTimeAtStartOfDay();
DateTime tomorrow = today.plusDays(1).withTimeAtStartOfDay();

Passez un fuseau horaire si vous ne voulez pas le fuseau horaire par défaut actuel de la JVM.

DateTimeZone timeZone = DateTimeZone.forID("America/Montreal");
DateTime today = new DateTime(timeZone).withTimeAtStartOfDay(); // Pass time zone to constructor.

Par souci d'exhaustivité, si vous utilisez Java 8, vous pouvez également utiliser la truncatedTométhode de la Instantclasse pour obtenir minuit en UTC .

Instant.now().truncatedTo(ChronoUnit.DAYS);

Comme écrit dans le Javadoc

Par exemple, la troncature avec l'unité MINUTES arrondira à la minute la plus proche, mettant les secondes et les nanosecondes à zéro.

J'espère que cela aide.

Le moyen le plus simple de trouver un minuit:

Long time = new Date().getTime();
Date date = new Date(time - time % (24 * 60 * 60 * 1000));

Le prochain jour:

Date date = new Date(date.getTime() + 24 * 60 * 60 * 1000);

N'oubliez pas, Daten'est pas utilisé pour représenter les dates (!). Pour représenter la date, vous avez besoin d'un calendrier. Ce:

Calendar c = new GregorianCalendar();

créera une Calendarinstance représentant la date actuelle dans votre fuseau horaire actuel. Maintenant, ce dont vous avez besoin est de tronquer chaque champ sous jour (heure, minute, seconde et milliseconde) en le définissant sur 0. Vous avez maintenant minuit aujourd'hui.

Maintenant, pour obtenir minuit le lendemain, vous devez ajouter un jour:

c.add(Calendar.DAY_OF_MONTH, 1);

Notez que l'ajout de 86400secondes ou de 24 heures est incorrect en raison de l'heure d'été qui peut se produire entre-temps.

MISE À JOUR: Cependant, ma façon préférée de résoudre ce problème est d'utiliser la classe DateUtils de Commons Lang :

Date start = DateUtils.truncate(new Date(), Calendar.DAY_OF_MONTH))
Date end = DateUtils.addDays(start, 1);

Il utilise Calendarles coulisses ...

ces méthodes vous aideront-

public static Date getStartOfDay(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();
 }

et

public static Date getEndOfDay(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();
}

Depuis JodaTime 2.3, le toDateMidnight() est obsolète.

De mise à niveau de la version 2.2 à la version 2.3

    Dépréciations depuis la version 2.2
    ----------------------
    - DateMidnight [# 41]
     Cette classe a un concept défectueux
     L'heure de minuit ne se produit parfois pas dans certains fuseaux horaires
     Ceci est le résultat d'une heure d'été de 00h00 à 01h00
     DateMidnight est essentiellement un DateTime avec une heure verrouillée à minuit
     Un tel concept est plus généralement médiocre à utiliser, étant donné LocalDate
     Remplacez DateMidnight par LocalDate
     Ou remplacez-le par DateTime, peut-être en utilisant la méthode withTimeAtStartOfDay ()

Voici un exemple de code sans toDateMidnight()méthode.

Code

DateTime todayAtMidnight = new DateTime().withTimeAtStartOfDay();
System.out.println(todayAtMidnight.toString("yyyy-MM-dd HH:mm:ss"));

Sortie ( peut être différente selon votre fuseau horaire local )

2013-09-28 00:00:00

D'autres réponses sont correctes, en particulier la réponse java.time par arganzheng . Comme certains l'ont mentionné, vous devriez éviter les anciennes classes java.util.Date/.Calendar car elles sont mal conçues, déroutantes et gênantes. Ils ont été supplantés par les classes java.time.

Permettez-moi d'ajouter des notes sur la stratégie concernant la gestion de minuit et les intervalles de temps .

À moitié ouvert

Dans le travail de date-heure, les intervalles de temps sont souvent définis à l'aide de l'approche «semi-ouverte». Dans cette approche, le début est inclusif tandis que la fin est exclusive . Cela résout les problèmes et, s'il est utilisé de manière cohérente, facilite grandement le raisonnement sur votre gestion de la date et de l'heure.

Un problème résolu est de définir la fin de la journée. Le dernier moment de la journée est-il 23:59:59.999( millisecondes )? Peut-être, dans la classe java.util.Date (du premier Java; gênant - évitez cette classe!) Et dans la bibliothèque Joda-Time très réussie . Mais dans d'autres logiciels, tels que des bases de données comme Postgres, le dernier moment sera 23:59:59.999999( microsecondes ). Mais dans d'autres logiciels tels que le framework java.time (intégré à Java 8 et versions ultérieures, successeur de Joda-Time) et dans certaines bases de données telles que H2 Database , le dernier moment pourrait être 23:59.59.999999999( nanosecondes ). Plutôt que de couper les cheveux, pensez uniquement au premier moment, pas au dernier moment.

En demi-ouverture, une journée court à partir du premier moment d'une journée et s'étend jusqu'au premier moment du jour suivant, mais n'inclut pas . Alors plutôt que de penser comme ça:

… À partir d'aujourd'hui à 00h00 (minuit tôt ce matin) à 12h00 (minuit ce soir).

… Pense comme ça…

depuis le premier moment d'aujourd'hui jusqu'au premier moment de demain, mais sans l'inclure:
(> = 00:00:00.0aujourd'hui ET < 00:00:00.0demain)

Dans le travail de base de données, cette approche signifie ne pas utiliser l' BETWEENopérateur dans SQL.

Début de la journée

De plus, le premier moment de la journée n'est pas toujours l'heure de la journée 00:00:00.0. L'heure d'été (DST) dans certains fuseaux horaires, et éventuellement d'autres anomalies, peut signifier qu'une heure différente commence la journée.

Laissez donc les classes java.time faire le travail de déterminer le début d'une journée avec un appel à LocalDate::atStartOfDay( ZoneId ). Nous devons donc faire un détour LocalDateet revenir ZonedDateTimecomme vous pouvez le voir dans cet exemple de code.

ZoneId zoneId = ZoneId.of( "America/Montreal" );
ZonedDateTime now = ZonedDateTime.now( zoneId );
ZonedDateTime todayStart = now.toLocalDate().atStartOfDay( zoneId );
ZonedDateTime tomorrowStart = todayStart.plusDays( 1 );

Notez le passage de l'option ZoneId. S'il est omis, le fuseau horaire par défaut actuel de votre JVM est appliqué implicitement. Mieux vaut être explicite.

Le fuseau horaire est crucial pour le travail date-heure. La question et certaines autres réponses sont potentiellement défectueuses car elles ne gèrent pas consciemment le fuseau horaire.

Convertir

Si vous devez utiliser un java.util.Date ou un .Calendar, recherchez les nouvelles méthodes de conversion ajoutées à ces anciennes classes.

java.util.Date utilDate = java.util.Date.from( todayStart.toInstant() );
java.util.GregorianCalendar gregCal = java.util.GregorianCalendar.from( todayStart );

Période de temps

À propos, si vous travaillez beaucoup avec des intervalles de temps, jetez un œil à:

• Duration
• Period
• Interval
  La Intervalclasse se trouve dans le projet ThreeTen-Extra , une extension du framework java.time. Ce projet est le terrain d'essai pour d'éventuels futurs ajouts à java.time.
  Interval todayMontreal = Interval.of( todayStart.toInstant() , tomorrowStart.toInstant() );

À propos de java.time

Le framework java.time est intégré à Java 8 et versions ultérieures. Ces classes supplantent les anciens gênants hérités des classes date-heure tels que java.util.Date, Calendar, et SimpleDateFormat.

Le projet Joda-Time , maintenant en mode maintenance , conseille la migration vers les classes java.time .

Pour en savoir plus, consultez le didacticiel Oracle . Et recherchez Stack Overflow pour de nombreux exemples et explications. La spécification est JSR 310 .

Vous pouvez échanger des objets java.time directement avec votre base de données. Utilisez un pilote JDBC compatible avec JDBC 4.2 ou version ultérieure. Pas besoin de chaînes, pas besoin de java.sql.*classes.

Où obtenir les classes java.time?

• Java SE 8 , Java SE 9 , Java SE 10 , Java SE 11 et versions ultérieures: partie de l'API Java standard avec une implémentation groupée.
  • Java 9 ajoute quelques fonctionnalités et corrections mineures.
• Java SE 6 et Java SE 7
  • La plupart des fonctionnalités java.time sont rétroportées vers Java 6 et 7 dans ThreeTen-Backport .
• Android
  • Versions ultérieures des implémentations de bundle Android des classes java.time .
  • Pour les versions antérieures d'Android (<26), le projet ThreeTenABP adapte ThreeTen-Backport (mentionné ci-dessus). Voir Comment utiliser ThreeTenABP… .

Le projet ThreeTen-Extra étend java.time avec des classes supplémentaires. Ce projet est un terrain d'essai pour d'éventuels futurs ajouts à java.time. Vous trouverez peut - être des classes utiles ici, comme Interval, YearWeek, YearQuarteret plus .

java.time

Si vous utilisez Java 8 et versions ultérieures, vous pouvez essayer le package java.time ( Tutoriel ):

LocalDate tomorrow = LocalDate.now().plusDays(1);
Date endDate = Date.from(tomorrow.atStartOfDay(ZoneId.systemDefault()).toInstant());

Cela semble être une option:

DateFormat justDay = new SimpleDateFormat("yyyyMMdd");
Date thisMorningMidnight = justDay.parse(justDay.format(new Date()));

pour y ajouter un jour, soit

Date tomorrow = new Date(thisMorningMidnight.getTime() + 24 * 60 * 60 * 1000);

ou

Calendar c = Calendar.getInstance();
c.setTime(thisMorningMidnight);
c.add(Calendar.DATE, 1);
Date tomorrowFromCalendar = c.getTime();

J'ai une idée que ce dernier est préféré en cas de quelque chose de bizarre comme l'heure d'été, ce qui fait que l'ajout de 24 heures ne suffit pas (voir https://stackoverflow.com/a/4336131/32453 et ses autres réponses).

Je l'ai fait différemment de tout le monde ici. Je suis nouveau sur Java, donc ma solution est peut-être mauvaise.

Date now = new Date();
Date midnightToday = new Date(now.getYear(), now.getMonth(), now.getDate());

Je ne suis pas sûr que cela fonctionne encore, mais de toute façon, j'apprécierais tout commentaire sur cette solution.

Je suis confus par la déclaration ci-dessus que vous pouvez calculer demain en appelant:

c.add(Calendar.DAY_OF_MONTH, 1);

Si vous ajoutez 1 au jour du mois et que c'est le 31e jour, n'obtenez-vous pas le 32e jour du mois?

Pourquoi les heures / dates ne sont-elles pas toutes basées sur UTC en Java? Je pense que les fuseaux horaires ne devraient être nécessaires que lorsqu'ils sont utilisés avec i / o, mais en interne, ils devraient toujours être utilisés en UTC. Cependant, les classes semblent inclure des informations sur le fuseau horaire qui semblent non seulement inutiles, mais sujettes à des erreurs de codage.

Apache Commons Lang

DateUtils.isSameDay(date1, date2)

http://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/time/DateUtils.html#isSameDay(java.util.Date , java.util.Date)

Le moyen le plus simple avec JodaTime

DateMidnight date = DateMidnight.now();

Parce qu'un jour est 24 * 60 * 60 * 1000ms, le minuit de ce jour peut être calculé comme ...

long now = System.currentTimeMillis();
long delta = now % 24 * 60 * 60 * 1000;
long midnight = now - delta;
Date midnightDate = new Date(midnight);`

À peu près comme les réponses précédentes, mais personne n'a mentionné le paramètre AM_PM:

    Calendar cal = Calendar.getInstance();
    cal.set(Calendar.HOUR, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    cal.set(Calendar.MILLISECOND, 0);
    cal.set(Calendar.AM_PM, Calendar.AM);

Date now= new Date();
// Today midnight
Date todayMidnight = new Date(endTime.getTime() -endTime.getTime()%DateUtils.MILLIS_PER_DAY);

// tomorrow midnight
Date tomorrowMidnight = new Date(endTime.getTime() -endTime.getTime()%DateUtils.MILLIS_PER_DAY + DateUtils.MILLIS_PER_DAY);

Utilisation d’apache commons.

//For midnight today 
Date today = new Date(); 
DateUtils.truncate(today, Calendar.DATE);

//For midnight tomorrow   
Date tomorrow = DateUtils.addDays(today, 1); 
DateUtils.truncate(tomorrow, Calendar.DATE);

Je sais que c'est un très vieux poste. J'ai pensé partager mes connaissances ici!

Pour la date Mid night aujourd'hui avec le fuseau horaire exact, vous pouvez utiliser ce qui suit

public static Date getCurrentDateWithMidnightTS(){

    return new Date(System.currentTimeMillis() - (System.currentTimeMillis()%(1000*60*60*24)) - (1000*60 * 330));
}

Où (1000*60 * 330)est soustrait, c'est-à-dire réellement lié au fuseau horaire, par exemple le fuseau horaire indien, c'est-à-dire que Kolkata diffère de +5: 30hrs du réel. Donc soustraire cela avec la conversion en millisecondes.

Alors changez le dernier numéro soustrait selon vous. Je crée un produit, c'est-à-dire uniquement basé en Inde. Je viens donc d'utiliser un horodatage spécifique.

Date todayMidnightUTC = java.sql.Date.valueOf(LocalDate.now());
Date tomorrowMidnightUTC = java.sql.Date.valueOf(LocalDate.now().plusDays(1));
Date anyMidnightLocal = java.sql.Date.valueOf(LocalDate.from(dateTime.toInstant().atZone(ZoneId.systemDefault())));

Mais attention, ça java.sql.Date.toInstant()jette toujours UnsupportedOperationException.

Via LocalDate vers java.util.Date et vice versa la conversion la plus simple?

À l'ancienne.

private static Date getDateWithMidnight(){
    long dateInMillis = new Date().getTime();
    return new Date(dateInMillis - dateInMillis%(1000*60*60*24) - TimeZone.getDefault().getOffset(dateInMillis));
}