Necesito comparar dos Dates (por ejemplo, date1y date2) y llegar a una boolean sameDayque sea verdadera para las dos Dates compartidas el mismo día, y falsa si no lo son.

¿Cómo puedo hacer esto? Parece que hay un torbellino de confusión aquí ... y me gustaría evitar atraer otras dependencias más allá del JDK si es posible.

para aclarar: si date1y date2comparte el mismo año, mes y día, entonces sameDayes cierto, de lo contrario es falso. Me doy cuenta de que esto requiere el conocimiento de una zona horaria ... sería bueno pasar en una zona horaria, pero puedo vivir con GMT o la hora local siempre que sepa cuál es el comportamiento.

de nuevo, para aclarar:

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

Tenga en cuenta que "el mismo día" no es un concepto tan simple como parece cuando pueden involucrarse diferentes zonas horarias. El código anterior calculará para ambas fechas el día relativo a la zona horaria utilizada por la computadora en la que se está ejecutando. Si esto no es lo que necesita, debe pasar la (s) zona (s) horaria (s) correspondiente (s) a las Calendar.getInstance()llamadas, después de haber decidido exactamente qué quiere decir con "el mismo día".

Y sí, Joda Time's LocalDateharía que todo fuera mucho más limpio y fácil (aunque las mismas dificultades relacionadas con las zonas horarias estarían presentes).

Qué tal si:

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

También puede establecer la zona horaria en SimpleDateFormat, si es necesario.

Utilizo el paquete "apache commons lang" para hacer esto (es decir, org.apache.commons.lang.time.DateUtils )

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

Puede evitar las dependencias externas y el impacto en el rendimiento del uso del Calendario calculando el Número de día juliano para cada una de las fechas y luego comparándolas:

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

En cuanto a agregar una dependencia, me temo que java.util.Date & .Calendar realmente son tan malos que lo primero que hago a cualquier proyecto nuevo es agregar la biblioteca Joda-Time. En Java 8 puede usar el nuevo paquete java.time, inspirado en Joda-Time.

El núcleo de Joda-Time es la DateTimeclase. A diferencia de java.util.Date, entiende su zona horaria asignada ( DateTimeZone). Al convertir de juDate, asigne una zona.

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

LocalDate

Una forma de verificar si dos fechas y horas aterrizan en la misma fecha es convertirlas en LocalDateobjetos.

Esa conversión depende de la zona horaria asignada. Para comparar LocalDateobjetos, deben haberse convertido con la misma zona.

Aquí hay un pequeño método de utilidad.

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

Mejor sería otro argumento, especificando la zona horaria en lugar de asumir que se debe usar la primera zona horaria del objeto DateTime.

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

Representación de cuerdas

Otro enfoque es crear una representación de cadena de la porción de fecha de cada fecha-hora, luego comparar cadenas.

Nuevamente, la zona horaria asignada es 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;

Lapso de tiempo

La solución generalizada es definir un período de tiempo, luego preguntar si el período contiene su objetivo. Este código de ejemplo está en Joda-Time 2.4. Tenga en cuenta que las clases relacionadas con la "medianoche" están en desuso. En su lugar, use el withTimeAtStartOfDaymétodo. Joda-Time ofrece tres clases para representar un lapso de tiempo de varias maneras: intervalo, período y duración.

Usando el enfoque "medio abierto" donde el comienzo del tramo es inclusivo y el final exclusivo.

La zona horaria del objetivo puede ser diferente a la zona horaria del intervalo.

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 y posterior viene con el framework java.time . Inspirado por Joda-Time, definido por JSR 310, y ampliado por el proyecto ThreeTen-Extra. Ver tutorial .

Los creadores de Joda-Time nos han ordenado a todos que nos traslademos a java.time tan pronto como sea conveniente. Mientras tanto, Joda-Time continúa como un proyecto mantenido activamente. Pero espere que el trabajo futuro ocurra solo en java.time y ThreeTen-Extra en lugar de Joda-Time.

Para resumir java.time en pocas palabras ... Un Instantes un momento en la línea de tiempo en UTC. Aplique una zona horaria ( ZoneId) para obtener un ZonedDateTimeobjeto. Para mover fuera de la línea de tiempo, para tener una idea vaga indefinida de una fecha-hora, utilice las clases "locales": LocalDateTime, LocalDate, LocalTime.

La lógica discutida en la sección Joda-Time de esta Respuesta se aplica a java.time.

La antigua clase java.util.Date tiene un nuevo toInstantmétodo para la conversión a java.time.

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

Determinar una fecha requiere una zona horaria.

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

Aplicamos ese objeto de zona horaria Instantpara obtener a ZonedDateTime. De ahí extraemos un valor de solo fecha (a LocalDate) ya que nuestro objetivo es comparar fechas (no horas, minutos, etc.).

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

Haga lo mismo con el segundo java.util.Dateobjeto que necesitamos para comparar. Solo usaré el momento actual en su lugar.

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

Use el isEqualmétodo especial para probar el mismo valor de fecha.

Boolean sameDate = localDate1.isEqual( localDate2 );

Convierta fechas a Java 8 java.time.LocalDate como se ve aquí .

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 está utilizando Java 8 en su proyecto y está comparando java.sql.Timestamp, podría usar la LocalDateclase:

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

Si está utilizando java.util.Date, eche un vistazo a la respuesta de Istvan, que es menos ambigua.

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

PARA USUARIOS DE ANDROID:

Puede usar DateUtils.isToday(dateMilliseconds)para verificar si la fecha dada es el día actual o no.

Referencia API: https://developer.android.com/reference/android/text/format/DateUtils.html#isToday(long)

Además de la solución 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;
}

uso

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

Para los desarrolladores de Kotlin, esta es la versión con enfoque de comparación de cadenas formateadas:

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

No es la mejor manera, pero es corta y funciona.

puede aplicar la misma lógica que la solución SimpleDateFormat sin depender de SimpleDateFormat

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