Je dois comparer deux Dates (par exemple date1et date2) et trouver unboolean sameDay qui est vrai pour les deux Dates partagent le même jour, et faux s'ils ne le sont pas.

Comment puis-je faire ceci? Il semble y avoir un tourbillon de confusion ici ... et je voudrais éviter de tirer dans d'autres dépendances au-delà du JDK si possible.

pour clarifier: si date1et date2partager la même année, le même mois et le même jour, alors sameDayc'est vrai, sinon c'est faux. Je me rends compte que cela nécessite la connaissance d'un fuseau horaire ... ce serait bien de passer dans un fuseau horaire, mais je peux vivre avec l'heure GMT ou locale tant que je sais quel est le comportement.

encore une fois, pour clarifier:

date1 = 2008 Jun 03 12:56:03
date2 = 2008 Jun 03 12:59:44
  => sameDate = true

date1 = 2009 Jun 03 12:56:03
date2 = 2008 Jun 03 12:59:44
  => sameDate = false

date1 = 2008 Aug 03 12:00:00
date2 = 2008 Jun 03 12:00:00
  => sameDate = false

Calendar cal1 = Calendar.getInstance();
Calendar cal2 = Calendar.getInstance();
cal1.setTime(date1);
cal2.setTime(date2);
boolean sameDay = cal1.get(Calendar.DAY_OF_YEAR) == cal2.get(Calendar.DAY_OF_YEAR) &&
                  cal1.get(Calendar.YEAR) == cal2.get(Calendar.YEAR);

Notez que «même jour» n'est pas un concept aussi simple qu'il y paraît lorsque différents fuseaux horaires peuvent être impliqués. Le code ci-dessus calculera pour les deux dates le jour par rapport au fuseau horaire utilisé par l'ordinateur sur lequel il s'exécute. Si ce n'est pas ce dont vous avez besoin, vous devez transmettre le (s) fuseau (s) horaire (s) correspondant (s) aux Calendar.getInstance()appels, après avoir décidé ce que vous entendez exactement par "le même jour".

Et oui, Joda Time LocalDaterendrait le tout beaucoup plus propre et plus facile (bien que les mêmes difficultés impliquant les fuseaux horaires soient présentes).

Que diriez-vous:

SimpleDateFormat fmt = new SimpleDateFormat("yyyyMMdd");
return fmt.format(date1).equals(fmt.format(date2));

Vous pouvez également définir le fuseau horaire sur SimpleDateFormat, si nécessaire.

J'utilise le package "apache commons lang" pour ce faire (à savoir org.apache.commons.lang.time.DateUtils )

boolean samedate = DateUtils.isSameDay(date1, date2);  //Takes either Calendar or Date objects

Vous pouvez éviter les dépendances externes et l'impact sur les performances de l'utilisation de Calendar en calculant le numéro du jour julien pour chacune des dates, puis en les comparant:

public static boolean isSameDay(Date date1, Date date2) {

    // Strip out the time part of each date.
    long julianDayNumber1 = date1.getTime() / MILLIS_PER_DAY;
    long julianDayNumber2 = date2.getTime() / MILLIS_PER_DAY;

    // If they now are equal then it is the same day.
    return julianDayNumber1 == julianDayNumber2;
}

Joda-Time

Quant à l'ajout d'une dépendance, je crains que les java.util.Date et .Calendar soient vraiment si mauvais que la première chose que je fais à tout nouveau projet est d'ajouter la bibliothèque Joda-Time. Dans Java 8, vous pouvez utiliser le nouveau package java.time, inspiré de Joda-Time.

Le cœur de Joda-Time est la DateTimeclasse. Contrairement à java.util.Date, il comprend le fuseau horaire qui lui est attribué ( DateTimeZone). Lors de la conversion de juDate, attribuez une zone.

DateTimeZone zone = DateTimeZone.forID( "America/Montreal" );
DateTime dateTimeQuébec = new DateTime( date , zone );

LocalDate

Une façon de vérifier si deux dates-heures atterrissent à la même date est de les convertir en LocalDateobjets.

Cette conversion dépend du fuseau horaire attribué. Pour comparer des LocalDateobjets, ils doivent avoir été convertis avec la même zone.

Voici une petite méthode utilitaire.

static public Boolean sameDate ( DateTime dt1 , DateTime dt2 )
{
    LocalDate ld1 = new LocalDate( dt1 );
    // LocalDate determination depends on the time zone.
    // So be sure the date-time values are adjusted to the same time zone.
    LocalDate ld2 = new LocalDate( dt2.withZone( dt1.getZone() ) );
    Boolean match = ld1.equals( ld2 );
    return match;
}

Mieux serait un autre argument, spécifiant le fuseau horaire plutôt que de supposer que le fuseau horaire du premier objet DateTime devrait être utilisé.

static public Boolean sameDate ( DateTimeZone zone , DateTime dt1 , DateTime dt2 )
{
    LocalDate ld1 = new LocalDate( dt1.withZone( zone ) );
    // LocalDate determination depends on the time zone.
    // So be sure the date-time values are adjusted to the same time zone.
    LocalDate ld2 = new LocalDate( dt2.withZone( zone ) );
    return ld1.equals( ld2 );
}

Représentation des chaînes

Une autre approche consiste à créer une représentation sous forme de chaîne de la partie date de chaque date-heure, puis à comparer les chaînes.

Encore une fois, le fuseau horaire attribué est crucial.

DateTimeFormatter formatter = ISODateTimeFormat.date();  // Static method.
String s1 = formatter.print( dateTime1 );
String s2 = formatter.print( dateTime2.withZone( dt1.getZone() )  );
Boolean match = s1.equals( s2 );
return match;

Durée du temps

La solution généralisée consiste à définir un intervalle de temps, puis demandez si l'intervalle contient votre cible. Cet exemple de code est dans Joda-Time 2.4. Notez que les classes liées à "minuit" sont obsolètes. Utilisez plutôt la withTimeAtStartOfDayméthode. Joda-Time propose trois classes pour représenter un laps de temps de différentes manières: Intervalle, Période et Durée.

Utilisation de l'approche "Half-Open" où le début de la plage est inclusif et la fin exclusive.

Le fuseau horaire de la cible peut être différent du fuseau horaire de l'intervalle.

DateTimeZone timeZone = DateTimeZone.forID( "Europe/Paris" );
DateTime target = new DateTime( 2012, 3, 4, 5, 6, 7, timeZone );
DateTime start = DateTime.now( timeZone ).withTimeAtStartOfDay();
DateTime stop = start.plusDays( 1 ).withTimeAtStartOfDay();
Interval interval = new Interval( start, stop );
boolean containsTarget = interval.contains( target );

java.time

Java 8 et versions ultérieures sont fournies avec le framework java.time . Inspiré par Joda-Time, défini par JSR 310, et étendu par le projet ThreeTen-Extra. Voir le tutoriel .

Les créateurs de Joda-Time nous ont tous demandé de passer à java.time dès que possible. Dans l'intervalle, Joda-Time continue d'être un projet activement maintenu. Mais attendez-vous à ce que les travaux futurs se produisent uniquement dans java.time et ThreeTen-Extra plutôt que Joda-Time.

Pour résumer java.time en quelques mots… An Instantest un moment sur la timeline en UTC. Appliquez un fuseau horaire ( ZoneId) pour obtenir un ZonedDateTimeobjet. Pour se déplacer hors de la ligne de temps, pour obtenir l'idée vague indéfinie d'une date-heure, utiliser les classes « locales »: LocalDateTime, LocalDate, LocalTime.

La logique discutée dans la section Joda-Time de cette réponse s'applique à java.time.

L'ancienne classe java.util.Date a une nouvelle toInstantméthode de conversion en java.time.

Instant instant = yourJavaUtilDate.toInstant(); // Convert into java.time type.

La détermination d'une date nécessite un fuseau horaire.

ZoneId zoneId = ZoneId.of( "America/Montreal" );

Nous appliquons cet objet de fuseau horaire au Instantpour obtenir un ZonedDateTime. De là, nous extrayons une valeur de date uniquement (a LocalDate) car notre objectif est de comparer les dates (pas les heures, les minutes, etc.).

ZonedDateTime zdt1 = ZonedDateTime.ofInstant( instant , zoneId );
LocalDate localDate1 = LocalDate.from( zdt1 );

Faites de même pour le deuxième java.util.Dateobjet dont nous avons besoin pour la comparaison. Je vais juste utiliser l'instant présent à la place.

ZonedDateTime zdt2 = ZonedDateTime.now( zoneId );
LocalDate localDate2 = LocalDate.from( zdt2 );

Utilisez la isEqualméthode spéciale pour tester la même valeur de date.

Boolean sameDate = localDate1.isEqual( localDate2 );

Convertissez les dates en Java 8 java.time.LocalDate comme on le voit ici .

LocalDate localDate1 = date1.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
LocalDate localDate2 = date2.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();

// compare dates
assertTrue("Not on the same day", localDate1.equals(localDate2));

Java 8

Si vous utilisez Java 8 dans votre projet et comparez java.sql.Timestamp, vous pouvez utiliser la LocalDateclasse:

sameDate = date1.toLocalDateTime().toLocalDate().equals(date2.toLocalDateTime().toLocalDate());

Si vous utilisez java.util.Date, jetez un œil à la réponse d'Istvan qui est moins ambiguë.

private boolean isSameDay(Date date1, Date date2) {
        Calendar calendar1 = Calendar.getInstance();
        calendar1.setTime(date1);
        Calendar calendar2 = Calendar.getInstance();
        calendar2.setTime(date2);
        boolean sameYear = calendar1.get(Calendar.YEAR) == calendar2.get(Calendar.YEAR);
        boolean sameMonth = calendar1.get(Calendar.MONTH) == calendar2.get(Calendar.MONTH);
        boolean sameDay = calendar1.get(Calendar.DAY_OF_MONTH) == calendar2.get(Calendar.DAY_OF_MONTH);
        return (sameDay && sameMonth && sameYear);
    }

POUR LES UTILISATEURS ANDROID:

Vous pouvez utiliser DateUtils.isToday(dateMilliseconds) pour vérifier si la date donnée est la journée en cours ou non.

Référence de l'API: https://developer.android.com/reference/android/text/format/DateUtils.html#isToday(long)

en plus de la solution Binil Thomas

public static boolean isOnSameDay(Timestamp... dates) {
    SimpleDateFormat fmt = new SimpleDateFormat("yyyyMMdd");
    String date1 = fmt.format(dates[0]);
    for (Timestamp date : dates) {
        if (!fmt.format(date).equals(date1)) {
            return false;
        }
    }
    return true;
}

usage

    isOnSameDay(date1,date2,date3 ...);
//or 
    isOnSameDay(mydates);

Pour les développeurs Kotlin, c'est la version avec la comparaison de l'approche des chaînes formatées:

val sdf = SimpleDateFormat("yyMMdd")
if (sdf.format(date1) == sdf.format(date2)) {
    // same day
}

Ce n'est pas la meilleure façon, mais c'est court et ça marche.

vous pouvez appliquer la même logique que la solution SimpleDateFormat sans compter sur SimpleDateFormat

date1.getFullYear()*10000 + date1.getMonth()*100 + date1.getDate() == 
date2.getFullYear()*10000 + date2.getMonth()*100 + date2.getDate()