我更倾向于直接使用Joda库而不是java.util.Date，因为Joda区分了日期和时间(参见YearMonthDay和DateTime类)。

然而，如果你确实希望使用java.util.Date，我建议写一个实用方法;如。

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

更新:虽然Joda Time在当时是一个很好的建议，使用java。在可能的情况下，从Java 8+替代时间库。

我倾向于使用Joda Time，这让这变得非常简单:

DateTime first = ...;
DateTime second = ...;

LocalDate firstDate = first.toLocalDate();
LocalDate secondDate = second.toLocalDate();

return firstDate.compareTo(secondDate);

编辑:正如评论中提到的，如果你使用DateTimeComparator.getDateOnlyInstance()，它甚至更简单:)

// TODO: consider extracting the comparator to a field.
return DateTimeComparator.getDateOnlyInstance().compare(first, second);

(“使用Joda Time”是几乎所有SO问题的基础，这些问题询问java.util.Date或java.util.Calendar。这是一个非常优秀的API。如果你要用日期/时间做任何重要的事情，你应该尽可能地使用它。)

如果必须使用内置API，则应该使用适当的日期和时区创建Calendar实例。然后，您可以将每个日历中的每个字段(小时、分钟、秒和毫秒)设置为0，并比较结果时间。与Joda解决方案相比，确实很讨厌:)

时区部分很重要:java.util.Date总是基于UTC。在大多数情况下，我对一个日期感兴趣，那是一个特定时区的日期。这本身将迫使您使用Calendar或Joda Time(除非您想自己考虑时区，我不建议这样做)。

android开发人员的快速参考

//Add joda library dependency to your build.gradle file
dependencies {
     ...
     implementation 'joda-time:joda-time:2.9.9'
}

示例代码(示例)

DateTimeComparator dateTimeComparator = DateTimeComparator.getDateOnlyInstance();

Date myDateOne = ...;
Date myDateTwo = ...;

int retVal = dateTimeComparator.compare(myDateOne, myDateTwo);

if(retVal == 0)
   //both dates are equal
else if(retVal < 0)
   //myDateOne is before myDateTwo
else if(retVal > 0)
   //myDateOne is after myDateTwo

如果你真的想使用java.util。约会时，你会这样做:

public class TimeIgnoringComparator implements Comparator<Date> {
  public int compare(Date d1, Date d2) {
    if (d1.getYear() != d2.getYear()) 
        return d1.getYear() - d2.getYear();
    if (d1.getMonth() != d2.getMonth()) 
        return d1.getMonth() - d2.getMonth();
    return d1.getDate() - d2.getDate();
  }
}

或者，使用Calendar代替(首选，因为getYear()等已弃用)

public class TimeIgnoringComparator implements Comparator<Calendar> {
  public int compare(Calendar c1, Calendar c2) {
    if (c1.get(Calendar.YEAR) != c2.get(Calendar.YEAR)) 
        return c1.get(Calendar.YEAR) - c2.get(Calendar.YEAR);
    if (c1.get(Calendar.MONTH) != c2.get(Calendar.MONTH)) 
        return c1.get(Calendar.MONTH) - c2.get(Calendar.MONTH);
    return c1.get(Calendar.DAY_OF_MONTH) - c2.get(Calendar.DAY_OF_MONTH);
  }
}

我也更喜欢Joda Time，但这里有一个替代方案:

long oneDay = 24 * 60 * 60 * 1000
long d1 = first.getTime() / oneDay
long d2 = second.getTime() / oneDay
d1 == d2

EDIT

我把UTC的东西放在下面，以防你需要比较UTC以外的特定时区的日期。如果你确实有这样的需求，那么我真的建议你去找Joda。

long oneDay = 24 * 60 * 60 * 1000
long hoursFromUTC = -4 * 60 * 60 * 1000 // EST with Daylight Time Savings
long d1 = (first.getTime() + hoursFromUTC) / oneDay
long d2 = (second.getTime() + hoursFromUTC) / oneDay
d1 == d2

恐怕没有一种方法可以比较两个日期，可以称之为“容易”或“简单”。

当比较两个精度降低的时间实例时(例如，只是比较日期)，你必须考虑时区对比较的影响。

例如，如果date1指定发生在+2时区的事件，而date2指定发生在EST时区的事件，则必须注意正确理解比较的含义。

你的目的是要弄清楚这两件事是否发生在各自时区的同一日历日期?或者，您是否需要知道这两个日期是否属于特定时区(例如，UTC或您的本地TZ)中的相同日历日期。

一旦你弄清楚你想要比较的是什么，就只需要在适当的时区获得年-月-日三元组合并进行比较。

Joda时间可能使实际的比较操作看起来更简洁，但是比较的语义仍然需要您自己弄清楚。

对这个替代方案有什么意见吗?

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

Apache commons-lang几乎无处不在。那么这个呢?

if (DateUtils.isSameDay(date1, date2)) {
    // it's same
} else if (date1.before(date2)) {
   // it's before
} else {
   // it's after
}

我的建议:

    Calendar cal = Calendar.getInstance();
    cal.set(1999,10,01);   // nov 1st, 1999
    cal.set(Calendar.AM_PM,Calendar.AM);
    cal.set(Calendar.HOUR,0);
    cal.set(Calendar.MINUTE,0);
    cal.set(Calendar.SECOND,0);
    cal.set(Calendar.MILLISECOND,0);

    // date column in the Thought table is of type sql date
    Thought thought = thoughtDao.getThought(date, language);

    Assert.assertEquals(cal.getTime(), thought.getDate());

这对我来说很管用:

var Date1 = new Date(dateObject1.toDateString()); //this sets time to 00:00:00
var Date2 = new Date(dateObject2.toDateString()); 
//do a normal compare
if(Date1 > Date2){ //do something }

这里有一个来自这个博客的解决方案:http://brigitzblog.blogspot.com/2011/10/java-compare-dates.html

long milliseconds1 = calendar1.getTimeInMillis();
long milliseconds2 = calendar2.getTimeInMillis();
long diff = milliseconds2 - milliseconds1;
long diffDays = diff / (24 * 60 * 60 * 1000);
System.out.println("Time in days: " + diffDays  + " days.");

也就是说，你可以看到以毫秒为单位的时间差是否小于一天的长度。

如果你只想比较两个没有时间的日期，那么下面的代码可能会帮助你:

final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
Date dLastUpdateDate = dateFormat.parse(20111116);
Date dCurrentDate = dateFormat.parse(dateFormat.format(new Date()));
if (dCurrentDate.after(dLastUpdateDate))
{
   add your logic
}

如果你只想比较两个日期的月、日和年，下面的代码适用于我:

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

谢谢抢劫。

已经提到了apache common -utils:

org.apache.commons.lang.time.DateUtils.truncate(date, Calendar.DAY_OF_MONTH)

给你Date对象，只包含日期，没有时间，你可以与Date. compareto进行比较

使用SimpleDateFormat的getDateInstance，我们只能比较两个没有时间的日期对象。执行下面的代码。

public static void main(String[] args) {        
        Date date1  = new Date();
        Date date2  = new Date();
        DateFormat dfg = SimpleDateFormat.getDateInstance(DateFormat.DATE_FIELD);
        String dateDtr1 = dfg.format(date1);
        String dateDtr2 = dfg.format(date2);
        System.out.println(dateDtr1+" : "+dateDtr2);
        System.out.println(dateDtr1.equals(dateDtr2));  

    }

只需结合YEAR属性检查DAY_OF_YEAR

boolean isSameDay = 
firstCal.get(Calendar.YEAR) == secondCal.get(Calendar.YEAR) &&
firstCal.get(Calendar.DAY_OF_YEAR) == secondCal.get(Calendar.DAY_OF_YEAR)

编辑:

现在我们可以使用Kotlin扩展函数的强大功能

fun Calendar.isSameDay(second: Calendar): Boolean {

    return this[Calendar.YEAR] == second[Calendar.YEAR] && this[Calendar.DAY_OF_YEAR] == second[Calendar.DAY_OF_YEAR]
}

fun Calendar.compareDatesOnly(other: Calendar): Int {

    return when {
        isSameDay(other) -> 0
        before(other) -> -1
        else -> 1
    }
}

`

SimpleDateFormat sdf= new SimpleDateFormat("MM/dd/yyyy")

   Date date1=sdf.parse("03/25/2015");



  Date currentDate= sdf.parse(sdf.format(new Date()));

   return date1.compareTo(currentDate);

`

DateUtil.daysBetween()怎么样?它是Java，它返回一个数字(以天为单位)。

在Java 8中，你可以使用与Joda Time非常相似的LocalDate。

另一个简单的比较方法是基于这里的答案和我的导师的指导

public static int compare(Date d1, Date d2) {
    Calendar c1 = Calendar.getInstance();
    Calendar c2 = Calendar.getInstance();
    c1.setTime(d1);
    c1.set(Calendar.MILLISECOND, 0);
    c1.set(Calendar.SECOND, 0);
    c1.set(Calendar.MINUTE, 0);
    c1.set(Calendar.HOUR_OF_DAY, 0);
    c2.setTime(d2);
    c2.set(Calendar.MILLISECOND, 0);
    c2.set(Calendar.SECOND, 0);
    c2.set(Calendar.MINUTE, 0);
    c2.set(Calendar.HOUR_OF_DAY, 0);
    return c1.getTime().compareTo(c2.getTime());
  }

编辑: 根据@Jonathan Drapeau的说法，上面的代码在某些情况下会失败(我想看看这些情况)，他建议如下:

public static int compare2(Date d1, Date d2) {
    Calendar c1 = Calendar.getInstance();
    Calendar c2 = Calendar.getInstance();
    c1.clear();
    c2.clear();
    c1.set(Calendar.YEAR, d1.getYear());
    c1.set(Calendar.MONTH, d1.getMonth());
    c1.set(Calendar.DAY_OF_MONTH, d1.getDay());
    c2.set(Calendar.YEAR, d2.getYear());
    c2.set(Calendar.MONTH, d2.getMonth());
    c2.set(Calendar.DAY_OF_MONTH, d2.getDay());
    return c1.getTime().compareTo(c2.getTime());
}

请注意，Date类已弃用，因为它不适合国际化。取而代之的是Calendar类!

使用http://mvnrepository.com/artifact/commons-lang/commons-lang

Date date1 = new Date();

Date date2 = new Date();

if (DateUtils.truncatedCompareTo(date1, date2, Calendar.DAY_OF_MONTH) == 0)
    // TRUE
else
    // FALSE

如果你使用的是Java 8，你应该使用Java .time。*类来比较日期-它优先于各种java.util。*类

如;https://docs.oracle.com/javase/8/docs/api/java/time/LocalDate.html

LocalDate date1 = LocalDate.of(2016, 2, 14);
LocalDate date2 = LocalDate.of(2015, 5, 23);
date1.isAfter(date2);

使用Apache commons你可以做到:

import org.apache.commons.lang3.time.DateUtils

DateUtils.truncatedEquals(first, second, Calendar.DAY_OF_MONTH)

public static Date getZeroTimeDate(Date fecha) {
    Date res = fecha;
    Calendar calendar = Calendar.getInstance();

    calendar.setTime( fecha );
    calendar.set(Calendar.HOUR_OF_DAY, 0);
    calendar.set(Calendar.MINUTE, 0);
    calendar.set(Calendar.SECOND, 0);
    calendar.set(Calendar.MILLISECOND, 0);

    res = calendar.getTime();

    return res;
}

Date currentDate = getZeroTimeDate(new Date());// get current date   

这是解决这个问题最简单的方法。

首先，请注意该操作取决于时区。所以你可以选择使用国际标准时间(UTC)、计算机时区、你自己喜欢的时区或其他地方。如果你还不相信这很重要，请参阅下面我的例子。

由于您的问题不是很清楚这一点，我假设您有一个类，它具有一个实例字段，表示时间点并实现Comparable，并且您希望对象的自然顺序是根据该字段的日期而不是时间。例如:

public class ArnesClass implements Comparable<ArnesClass> {

    private static final ZoneId arnesTimeZone = ZoneId.systemDefault();

    private Instant when;

    @Override
    public int compareTo(ArnesClass o) {
        // question is what to put here
    }

}

Java 8 Java。时间类

我已经自由地将实例字段的类型从Date更改为Instant，这是Java 8中对应的类。我保证会继续下面对Date的处理。我还添加了一个时区常数。您可以将其设置为ZoneOffset。UTC或ZoneId.of("Europe/Stockholm")或您认为合适的名称(将其设置为ZoneOffset是有效的，因为ZoneOffset是ZoneId的子类)。

我选择使用Java 8类来展示解决方案。你要的是最简单的方法，对吧?:-)这是你要求的compareTo方法:

public int compareTo(ArnesClass o) {
    LocalDate dateWithoutTime = when.atZone(arnesTimeZone).toLocalDate();
    LocalDate otherDateWithoutTime = o.when.atZone(arnesTimeZone).toLocalDate();
    return dateWithoutTime.compareTo(otherDateWithoutTime);
}

如果您永远不需要when的时间部分，那么声明when为LocalDate并跳过所有转换当然更容易。那我们也不用担心时区的问题了。

现在假设由于某种原因，您不能将您的when字段声明为Instant，或者希望将其保留为老式的Date。如果你仍然可以使用Java 8，只需将其转换为Instant，然后像以前那样做:

    LocalDate dateWithoutTime = when.toInstant().atZone(arnesTimeZone).toLocalDate();

与o.when类似。

没有Java 8?

如果你不能使用java 8，有两个选项:

使用一个旧类(Calendar或SimpleDateFormat)来解决这个问题。 使用Java 8日期和时间类的后端口到Java 6和7，然后执行上述操作。我在底部附上了一个链接。不要使用JodaTime。JodaTime可能是一个很好的建议，当答案推荐它编写;但是JodaTime现在处于维护模式，所以ThreeTen后端口是一个更好的、更适合未来的选择。

传统的方式

Adamski的回答向您展示了如何使用Calendar类从Date中剥离时间部分。我建议您使用getInstance(TimeZone)来获取所需时区的Calendar实例。作为替代，你可以使用Jorn回答的后半部分的想法。

使用SimpleDateFormat实际上是使用Calendar的一种间接方式，因为SimpleDateFormat包含一个Calendar对象。然而，你可能会发现它比直接使用Calendar麻烦得多:

private static final TimeZone arnesTimeZone = TimeZone.getTimeZone("Europe/Stockholm");
private static final DateFormat formatter = new SimpleDateFormat("yyyyMMdd");
static {
    formatter.setTimeZone(arnesTimeZone);
}

private Date when;

@Override
public int compareTo(ArnesClass o) {
    return formatter.format(when).compareTo(formatter.format(o.when));
}

这是受到了罗伯的回答的启发。

时区依赖性

Why do we have to pick a specific time zone? Say that we want to compare two times that in UTC are March 24 0:00 (midnight) and 12:00 (noon). If you do that in CET (say, Europe/Paris), they are 1 am and 1 pm on March 24, that is, the same date. In New York (Eastern Daylight Time), they are 20:00 on March 23 and 8:00 on March 24, that is, not the same date. So it makes a difference which time zone you pick. If you just rely on the computer’s default, you may be in for surprises when someone tries to run your code on a computer in another place in this globalized world.

Link

链接到ThreeTen Backport, Java 8日期和时间类到Java 6和7的后端口:http://www.threeten.org/threetenbp/。

博士tl;

myJavaUtilDate1.toInstant()
               .atZone( ZoneId.of( "America/Montreal" ) )
               .toLocalDate()
               .isEqual (
                   myJavaUtilDate2.toInstant()
                                  .atZone( ZoneId.of( "America/Montreal" ) )
                                  .toLocalDate()
               )

避免遗留的日期-时间类

避免麻烦的旧的遗留日期时间类，如Date & Calendar，现在已被java所取代。时间类。

使用java.time

date表示时间轴上的一个UTC时间点。在java中是等价的。时间就是瞬间。您可以使用添加到遗留类中的新方法进行转换。

Instant instant1 = myJavaUtilDate1.toInstant();
Instant instant2 = myJavaUtilDate2.toInstant();

您希望根据日期进行比较。时区是决定日期的关键。对于任何给定的时刻，全球各地的日期都因地区而异。例如，法国巴黎午夜过后几分钟就是新的一天，但在Montréal Québec上仍然是“昨天”。

请指定合适的时区名称，如“America/Montreal”、“Africa/Casablanca”或“Pacific/Auckland”。不要使用3-4个字母的缩写，如EST或IST，因为它们不是真正的时区，不是标准化的，甚至不是唯一的(!)。

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

将ZoneId应用到Instant以获得zoneeddatetime。

ZonedDateTime zdt1 = instant1.atZone( z );
ZonedDateTime zdt2 = instant2.atZone( z );

LocalDate类表示一个只包含日期的值，不包含日期和时区。我们可以从ZonedDateTime中提取LocalDate，有效地消除了日期部分。

LocalDate localDate1 = zdt1.toLocalDate();
LocalDate localDate2 = zdt2.toLocalDate();

现在使用isEqual、isBefore和isAfter等方法进行比较。

Boolean sameDate = localDate1.isEqual( localDate2 );

请在IdeOne.com上查看实时运行的代码。

即时1： 2017-03-25T04：13：10.971Z |即时2： 2017-03-24T22：13：10.972Z ZDT1： 2017-03-25T00：13：10.971-04：00[美国/蒙特利尔] |ZDT2：2017-03-24T18：13：10.972-04：00[美国/蒙特利尔] 本地日期1： 2017-03-25 |本地日期2： 2017-03-24 同一日期：假

关于java.time

java。时间框架内置于Java 8及更高版本中。这些类取代了麻烦的旧遗留日期-时间类，如java.util。日期，日历和简单日期格式。

Joda-Time项目现在处于维护模式，建议迁移到java。时间类。

要了解更多，请参阅Oracle教程。搜索Stack Overflow可以找到很多例子和解释。规范是JSR 310。

从哪里获取java。时间类?

Java SE 8和SE 9及更高版本 内置的。 带有捆绑实现的标准Java API的一部分。 Java 9增加了一些小特性并进行了修复。 Java SE 6和SE 7 大部分的java。时间功能在ThreeTen-Backport中向后移植到Java 6和7。 安卓 ThreeTenABP项目将ThreeTen-Backport(上文提到过)专门用于Android。 参见如何使用ThreeTenABP....

ThreeTen-Extra项目扩展了java。额外的课程时间。这个项目是未来可能添加到java.time的一个试验场。你可以在这里找到一些有用的类，比如Interval、YearWeek、YearQuarter等等。

public Date saveDateWithoutTime(Date date) {
    Calendar calendar = Calendar.getInstance();

    calendar.setTime( date );
    calendar.set(Calendar.HOUR_OF_DAY, 0);
    calendar.set(Calendar.HOUR, 0);
    calendar.set(Calendar.MINUTE, 0);
    calendar.set(Calendar.SECOND, 0);
    calendar.set(Calendar.MILLISECOND, 0);

    return calendar.getTime();
}

这将帮助你在不考虑时间的情况下比较日期。

我通过比较时间戳来解决这个问题:

    Calendar last = Calendar.getInstance();

    last.setTimeInMillis(firstTimeInMillis);

    Calendar current = Calendar.getInstance();

    if (last.get(Calendar.DAY_OF_MONTH) != current.get(Calendar.DAY_OF_MONTH)) {
        //not the same day
    }

我避免使用Joda Time，因为在Android上占用很大的空间。规模很重要。,)

我不知道这是新的想法或其他，但我给你展示我所做的

SimpleDateFormat dtf = new SimpleDateFormat("dd/MM/yyyy");
Date td_date = new Date();
String first_date = dtf.format(td_date);    //First seted in String 
String second_date = "30/11/2020";          //Second date you can set hear in String

String result = (first_date.equals(second_date)) ? "Yes, Its Equals":"No, It is not Equals";
System.out.println(result);

使用Java 8和Instant的另一个解决方案是使用truncatedTo方法

返回截断为指定单位的此即时的副本。

例子:

@Test
public void dateTruncate() throws InterruptedException {
    Instant now = Instant.now();
    Thread.sleep(1000*5);
    Instant later = Instant.now();
    assertThat(now, not(equalTo(later)));
    assertThat(now.truncatedTo(ChronoUnit.DAYS), equalTo(later.truncatedTo(ChronoUnit.DAYS)));
}

// Create one day 00:00:00 calendar
int oneDayTimeStamp = 1523017440;
Calendar oneDayCal = Calendar.getInstance();
oneDayCal.setTimeInMillis(oneDayTimeStamp * 1000L);
oneDayCal.set(Calendar.HOUR_OF_DAY, 0);
oneDayCal.set(Calendar.MINUTE, 0);
oneDayCal.set(Calendar.SECOND, 0);
oneDayCal.set(Calendar.MILLISECOND, 0);

// Create current day 00:00:00 calendar
Calendar currentCal = Calendar.getInstance();
currentCal.set(Calendar.HOUR_OF_DAY, 0);
currentCal.set(Calendar.MINUTE, 0);
currentCal.set(Calendar.SECOND, 0);
currentCal.set(Calendar.MILLISECOND, 0);

if (oneDayCal.compareTo(currentCal) == 0) {
    // Same day (excluding time)
}

如果严格使用Date (java.util.Date)，或者不使用任何外部库。用这个:

public Boolean compareDateWithoutTime(Date d1, Date d2) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
    return sdf.format(d1).equals(sdf.format(d2));
}

    Date today = new Date();
    Date endDate = new Date();//this
    endDate.setTime(endDate.getTime() - ((endDate.getHours()*60*60*1000) + (endDate.getMinutes()*60*1000) + (endDate.getSeconds()*1000)));
    today.setTime(today.getTime() - ((today.getHours()*60*60*1000) + (today.getMinutes()*60*1000) + (today.getSeconds()*1000)));

    System.out.println(endDate.compareTo(today) <= 0);

我只是将小时/分/秒设置为0，所以时间没有问题，因为现在两个日期的时间都是相同的。现在只需使用compareTo。这个方法帮助找到“if dueDate is today”，其中true表示Yes。

如果你正在寻找一个简单的解决方案，但你不想从你的项目中更改已弃用的java.util.Date类，你可以将这个方法添加到你的项目中，并继续你的探索:

使用java.util.concurrent.TimeUnit

`

public boolean isSameDay(Date first, Date second) {
    long difference_In_Time = first.getTime() - second.getTime();
        // calculate difference in days
        long difference_In_Days = 
        TimeUnit
              .MILLISECONDS
              .toDays(difference_In_Time);
        if (difference_In_Days == 0) {
            return true;
        }
        return false;
    }

`

像这样实现它:

`

Date first = ...;
Date second = ...;
if (isSameDay(first, second)) {
    // congratulations, they are the same
}
else {
   // heads up champ, they are not the same
}

`