Suite du programme Java de la question Stack Overflow pour obtenir la date actuelle sans horodatage :

Quelle est la façon la plus efficace d'obtenir un objet Date sans l'heure? Y a-t-il un autre moyen que ces deux-là?

// Method 1
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date dateWithoutTime = sdf.parse(sdf.format(new Date()));

// Method 2
Calendar cal = Calendar.getInstance();
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
dateWithoutTime = cal.getTime();

Mise à jour :

1. Je connaissais Joda-Time ; J'essaie juste d'éviter une bibliothèque supplémentaire pour une tâche aussi simple (je pense). Mais d'après les réponses jusqu'à présent, Joda-Time semble extrêmement populaire, donc je pourrais y penser.

2. Par efficace , je veux dire que je veux éviter la Stringcréation d' objets temporaires telle qu'utilisée par method 1, en attendant, cela method 2ressemble à un hack au lieu d'une solution.

Avez - vous absolument avoir à utiliser java.util.Date? Je bien vous recommandons d' utiliser Joda temps ou le java.timepackage de Java 8 au lieu. En particulier, alors que la date et le calendrier toujours représentent un instant particulier dans le temps, sans ce concept comme « juste une date », Joda Time ne possède un type qui représente ce ( LocalDate). Votre code sera beaucoup plus clair si vous pouvez utiliser des types qui représentent ce que vous essayez de faire.

Il existe de nombreuses autres raisons d'utiliser Joda Time ou java.timeau lieu des java.utiltypes intégrés - ce sont généralement de bien meilleures API. Vous pouvez toujours convertir vers / depuis a java.util.Dateaux limites de votre propre code si vous en avez besoin, par exemple pour l'interaction avec la base de données.

Voici ce que j'ai utilisé pour obtenir la date d'aujourd'hui avec l'heure définie sur 00:00:00:

DateFormat formatter = new SimpleDateFormat("dd/MM/yyyy");

Date today = new Date();

Date todayWithZeroTime = formatter.parse(formatter.format(today));

Vous pouvez utiliser le DateUtils.truncate de la bibliothèque Apache Commons.

Exemple:

DateUtils.truncate(new Date(), java.util.Calendar.DAY_OF_MONTH)

Y a-t-il un autre moyen que ces deux-là?

Oui il y a.

LocalDate.now( 
    ZoneId.of( "Pacific/Auckland" ) 
)

java.time

Java 8 et versions ultérieures sont livrées avec le nouveau package java.time intégré . Voir Tutoriel . Une grande partie de la fonctionnalité java.time est rétroportée vers Java 6 et 7 dans ThreeTen-Backport et adaptée à Android dans ThreeTenABP .

Semblable à Joda-Time , java.time propose une LocalDateclasse pour représenter une valeur de date uniquement sans heure et sans fuseau horaire.

Notez que le fuseau horaire est essentiel pour déterminer une date particulière. Par exemple, à minuit à Paris, la date est encore «hier» à Montréal.

LocalDate today = LocalDate.now( ZoneId.of( "America/Montreal" ) ) ;

Par défaut, java.time utilise la norme ISO 8601 pour générer une représentation sous forme de chaîne d'une date ou d'une date-heure. (Une autre similitude avec Joda-Time.) Il suffit donc d'appeler toString()pour générer du texte comme 2015-05-21.

String output = today.toString() ; 

À 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 , désormais 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 .

Où obtenir les classes java.time?

• Java SE 8 , Java SE 9 et versions ultérieures
  • Intégré.
  • Une partie de l'API Java standard avec une implémentation groupée.
  • Java 9 ajoute quelques fonctionnalités et correctifs mineurs.
• Java SE 6 et Java SE 7
  • Une grande partie de la fonctionnalité java.time est rétroportée vers Java 6 et 7 dans ThreeTen-Backport .
• Android
  • Versions ultérieures des implémentations de bundles Android des classes java.time.
  • Pour les versions antérieures d'Android, 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 de futurs ajouts possibles à java.time. Vous trouverez peut - être des classes utiles ici, comme Interval, YearWeek, YearQuarteret plus .

La manière la plus simple:

long millisInDay = 60 * 60 * 24 * 1000;
long currentTime = new Date().getTime();
long dateOnly = (currentTime / millisInDay) * millisInDay;
Date clearDate = new Date(dateOnly);

La réponse standard à ces questions est d'utiliser Joda Time . L'API est meilleure et si vous utilisez les formateurs et les analyseurs, vous pouvez éviter le manque non intuitif de sécurité des threads SimpleDateFormat.

Utiliser Joda signifie que vous pouvez simplement faire:

LocalDate d = new LocalDate();

Update :: Using java 8 this can be acheived using

LocalDate date = LocalDate.now();

C'est une façon simple de le faire:

Calendar cal = Calendar.getInstance();
SimpleDateFormat dateOnly = new SimpleDateFormat("MM/dd/yyyy");
System.out.println(dateOnly.format(cal.getTime()));

Il n'est pas logique de parler d'une date sans horodatage en ce qui concerne les routines Date dans l'exécution Java standard, car elle correspond essentiellement à une milliseconde spécifique et non à une date. Cette milliseconde est intrinsèquement associée à une heure de la journée, ce qui la rend vulnérable aux problèmes de fuseau horaire tels que l'heure d'été et d'autres ajustements de calendrier. Voir Pourquoi soustraire ces deux fois (en 1927) donne-t-il un résultat étrange? pour un exemple intéressant.

Si vous souhaitez travailler avec des dates au lieu de millisecondes, vous devez utiliser autre chose. Pour Java 8, il existe un nouvel ensemble de méthodes fournissant exactement ce que vous demandez. Pour Java 7 et versions antérieures, utilisez http://www.joda.org/joda-time/

Certainement pas la manière la plus correcte, mais si vous avez juste besoin d'une solution rapide pour obtenir la date sans l'heure et que vous ne souhaitez pas utiliser une bibliothèque tierce, cela devrait faire

    Date db = db.substring(0, 10) + db.substring(23,28);

Je n'avais besoin de la date qu'à des fins visuelles et je ne pouvais pas Joda donc j'ai sous-chaîne.

// 09/28/2015
System.out.println(new SimpleDateFormat("MM/dd/yyyy").format(Calendar.getInstance().getTime()));

// Mon Sep 28
System.out.println( new Date().toString().substring(0, 10) );

// 2015-09-28
System.out.println(new java.sql.Date(System.currentTimeMillis()));

// 2015-09-28
// java 8
System.out.println( LocalDate.now(ZoneId.of("Europe/Paris")) ); // rest zones id in ZoneId class

Pour autant que je sache, il n'y a pas de moyen plus simple d'y parvenir si vous utilisez uniquement le JDK standard.

Vous pouvez, bien sûr, mettre cette logique dans method2 dans une fonction statique dans une classe d'assistance, comme cela est fait ici dans la méthode toBeginningOfTheDay

Ensuite, vous pouvez raccourcir la deuxième méthode pour:

Calendar cal = Calendar.getInstance();
Calendars.toBeginningOfTheDay(cal);
dateWithoutTime = cal.getTime();

Ou, si vous avez vraiment besoin de la journée en cours dans ce format si souvent, vous pouvez simplement l'envelopper dans une autre méthode d'assistance statique, ce qui en fait une ligne unique.

Si tout ce que vous voulez est de voir la date comme "AAAA-MM-JJ" sans tous les autres fouillis, par exemple "jeu 21 mai 12:08:18 EDT 2015", utilisez simplement java.sql.Date. Cet exemple obtient la date actuelle:

new java.sql.Date(System.currentTimeMillis());

Est également java.sql.Dateune sous-classe de java.util.Date.

Si vous avez juste besoin de la date actuelle, sans heure, une autre option est:

DateTime.now().withTimeAtStartOfDay()

Utilisez LocalDate.now()et convertissez en Datecomme ci-dessous:

Date.from(LocalDate.now().atStartOfDay(ZoneId.systemDefault()).toInstant());

Si vous avez besoin de la partie date juste pour faire écho, alors

Date d = new Date(); 
String dateWithoutTime = d.toString().substring(0, 10);

Et ça?

public static Date formatStrictDate(int year, int month, int dayOfMonth) {
    Calendar calendar = Calendar.getInstance();
    calendar.set(year, month, dayOfMonth, 0, 0, 0);
    calendar.set(Calendar.MILLISECOND, 0);
    return calendar.getTime();
}

Découvrez l' heure de Veyder . C'est une alternative simple et efficace à la fois à java.util et à Joda-time. Il dispose d'une API et de classes intuitives qui représentent uniquement les dates, sans horodatage.

La manière la plus directe qui utilise pleinement l'énorme base de données TimeZone de Java et est correcte:

long currentTime = new Date().getTime();
long dateOnly = currentTime + TimeZone.getDefault().getOffset(currentTime);

Voici une solution propre sans conversion en chaîne et retour, et elle ne recalcule pas le temps plusieurs fois lorsque vous réinitialisez chaque composant du temps à zéro. Il utilise également %(module) plutôt que de diviser suivi de multiplier pour éviter la double opération.

Elle ne nécessite aucune dépendance tierce et RESPECTE LA FUSEAU HORAIRE DE L'OBJET CALENDRE passé. Cette fonction retourne l'instant à 12 h 00 dans le fuseau horaire de la date (calendrier) que vous passez.

public static Calendar date_only(Calendar datetime) {
    final long LENGTH_OF_DAY = 24*60*60*1000;
    long millis = datetime.getTimeInMillis();
    long offset = datetime.getTimeZone().getOffset(millis);
    millis = millis - ((millis + offset) % LENGTH_OF_DAY);
    datetime.setTimeInMillis(millis);
    return datetime;
}

Préférez ne pas utiliser autant que possible des bibliothèques tierces. Je sais que cette façon est mentionnée auparavant, mais voici une belle façon propre:

  /*
    Return values:
    -1:    Date1 < Date2
     0:    Date1 == Date2
     1:    Date1 > Date2

    -2:    Error
*/
public int compareDates(Date date1, Date date2)
{
    SimpleDateFormat sdf = new SimpleDateFormat("ddMMyyyy");

    try
    {
        date1 = sdf.parse(sdf.format(date1));
        date2 = sdf.parse(sdf.format(date2));
    }
    catch (ParseException e) {
        e.printStackTrace();
        return -2;
    }

    Calendar cal1 = new GregorianCalendar();
    Calendar cal2 = new GregorianCalendar();

    cal1.setTime(date1);
    cal2.setTime(date2);

    if(cal1.equals(cal2))
    {
        return 0;
    }
    else if(cal1.after(cal2))
    {
        return 1;
    }
    else if(cal1.before(cal2))
    {
        return -1;
    }

    return -2;
}

Eh bien, ne pas utiliser GregorianCalendar est peut-être une option!

Je viens de faire cela pour mon application:

public static Date getDatePart(Date dateTime) {
    TimeZone tz = TimeZone.getDefault();
    long rawOffset=tz.getRawOffset();
    long dst=(tz.inDaylightTime(dateTime)?tz.getDSTSavings():0);
    long dt=dateTime.getTime()+rawOffset+dst; // add offseet and dst to dateTime
    long modDt=dt % (60*60*24*1000) ;

    return new Date( dt
                    - modDt // substract the rest of the division by a day in milliseconds
                    - rawOffset // substract the time offset (Paris = GMT +1h for example)
                    - dst // If dayLight, substract hours (Paris = +1h in dayLight)
    );
}

API Android niveau 1, pas de bibliothèque externe. Il respecte la lumière du jour et la zone horaire par défaut. Aucune manipulation de chaîne, donc je pense que cette méthode est plus efficace que la vôtre, mais je n'ai fait aucun test.

Vous pouvez utiliser le temps Joda.

private Date dateWitoutTime(Date date){
 return new LocalDate(date).toDate()
}

et vous appelez avec:

Date date = new Date();
System.out.println("Without Time = " + dateWitoutTime(date) + "/n  With time = " + date);