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

请注意，当涉及不同时区时，“同一天”并不是一个听起来那么简单的概念。上面的代码将针对这两个日期计算相对于运行它的计算机所使用的时区的日期。如果这不是您所需要的，那么您必须将相关的时区传递给Calendar.getInstance()调用，在您确定了“同一天”的确切含义之后。

是的，Joda Time的LocalDate将使整个事情更加清晰和简单(尽管涉及时区的同样困难也会存在)。

我使用“apache commons lang”包来做到这一点(即org.apache.commons.lang.time.DateUtils)

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

如何:

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

如果需要，还可以将时区设置为SimpleDateFormat。

通过计算每个日期的儒略日数，然后比较这些日期，您可以避免外部依赖关系和使用Calendar的性能影响:

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

您可以应用与SimpleDateFormat解决方案相同的逻辑，而不依赖于SimpleDateFormat

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

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

使用

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

乔达时间

至于添加依赖项，我担心java.util.Date和. calendar真的很糟糕，以至于我对任何新项目所做的第一件事就是添加Joda-Time库。在Java 8中，您可以使用新的Java。时间包，灵感来自Joda-Time。

Joda-Time的核心是DateTime类。不像java.util。日期，它理解它分配的时区(DateTimeZone)。当从j.u.d date转换时，分配一个区域。

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

LocalDate

验证两个日期时间是否位于同一日期的一种方法是将其转换为LocalDate对象。

这种转换取决于所分配的时区。要比较LocalDate对象，它们必须转换为相同的区域。

这里有一个小实用方法。

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

更好的是另一个参数，指定时区，而不是假设应该使用第一个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 );
}

字符串表示形式

另一种方法是创建每个日期-时间的日期部分的字符串表示形式，然后比较字符串。

同样，指定的时区也很重要。

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;

时间跨度

通用的解决方案是定义一个时间跨度，然后询问这个跨度是否包含您的目标。这个示例代码在Joda-Time 2.4中。注意，与“midnight”相关的类已弃用。相反，使用withTimeAtStartOfDay方法。Joda-Time提供了三个类来以不同的方式表示时间跨度:间隔、周期和持续时间。

使用“半开放”方法，其中跨度的开始是包容性的，结束是排他性的。

目标器的时区和间隔的时区可以不同。

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和更高版本的Java。时间框架。灵感来自Joda-Time，由JSR 310定义，并由ThreeTen-Extra项目扩展。看教程。

Joda-Time的创造者已经指示我们所有人转移到java。时间越方便越好。与此同时，Joda-Time继续作为一个积极维护的项目。但预计未来的工作将只在java中进行。time和three - ten - extra而不是Joda-Time。

总结一下java。一个瞬间是UTC时间轴上的一个时刻。应用一个时区(ZoneId)来获得一个zoneeddatetime对象。要脱离时间轴，获得日期-时间的模糊不确定的概念，请使用“本地”类:LocalDateTime、LocalDate、LocalTime。

本回答的Joda-Time部分中讨论的逻辑适用于java.time。

旧的java.util.Date类有一个新的toInstant方法，用于转换为java.time。

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

确定日期需要时区。

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

我们将该时区对象应用于Instant以获得一个zoneeddatetime。从中提取一个仅限日期的值(LocalDate)，因为我们的目标是比较日期(而不是小时、分钟等)。

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

对用于比较的第二个java.util.Date对象执行同样的操作。我用现在的时间来代替。

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

使用特殊的isEqual方法来测试相同的日期值。

Boolean sameDate = localDate1.isEqual( localDate2 );

Java 8

如果你在你的项目中使用Java 8，并比较Java .sql。时间戳，你可以使用LocalDate类:

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

如果您正在使用java.util。日期，看看伊斯特万的答案，它不那么含糊。

转换日期到Java 8 Java .time. localdate 如图所示。

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

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

对于android用户:

您可以使用DateUtils.isToday(datemillisecseconds)来检查给定的日期是否是当前日期。

API参考:https://developer.android.com/link /android/text/text/dateutils.html @ isToday(long)

对于Kotlin开发者来说，这是比较格式化字符串方法的版本:

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

这不是最好的方法，但它既短又有效。

在JAVA 8中，我们可以将Date对象转换为LocalDate对象，因此我们可以这样做:

public static boolean isDatesAreDifferentDays(Date date1,Date date2)
{
    LocalDate d1 = date1.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
    LocalDate d2 = date2.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
    if(d1.getDayOfMonth() != d2.getDayOfMonth())
    {
        return false;
    }
    else if(d1.getMonth() != d2.getMonth())
    {
        return false;
    }
    else if(d1.getYear() != d2.getYear())
    {
        return false;
    }
    else
    {
        return true;
    }
}

更快的解决方案

像@AyeJay解决方案，但正确的所有时区，在时间戳中添加偏移量。

  public static boolean isSameDay(Date dateA, Date dateB) {
    int offset = TimeZone.getDefault().getRawOffset();
    try {
        long julianDayNumber1 = (dateA.getTime() + offset) / MILLIS_PER_DAY;
        long julianDayNumber2 = (dateB.getTime() + offset) / MILLIS_PER_DAY;
        return julianDayNumber1 == julianDayNumber2;
    } catch (Exception e) {
        return false;
    }
}