我想有一个compareTo方法，它忽略java.util.Date的时间部分。我想有很多方法可以解决这个问题。最简单的方法是什么？

更新：虽然Joda Time当时是一个不错的建议，但请java.time尽可能使用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时间”是几乎所有询问java.util.Date或的SO问题的基础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

Apache commons-lang几乎无处不在。那呢？

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

如果您确实想使用java.util.Date，则可以执行以下操作：

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

或改为使用日历（首选，因为不建议使用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库insetad 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();
}

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

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

如果您只想比较两个日期的月，日和年，以下代码对我有用：

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

谢谢罗伯。

我也更喜欢Joda Time，但这是一个替代方案：

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

编辑

我将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

tl; dr

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

避免使用旧的日期时间类

避免麻烦的旧式旧式日期时间类，例如Date＆Calendar，而该类现在已被java.time类取代。

使用java.time

A java.util.Date代表UTC时间轴上的时刻。java.time中的等效项是Instant。您可以使用添加到旧类中的新方法进行转换。

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

您想按日期比较。时区对于确定日期至关重要。在任何给定时刻，日期都会在全球范围内变化。例如，法国巴黎午夜过后的几分钟是新的一天，而在魁北克蒙特利尔仍然是“昨天” 。

指定适当的时区名称，格式continent/region，如America/Montreal，Africa/Casablanca或Pacific/Auckland。切勿使用3-4字母的缩写，例如EST或，IST因为它们不是真实的时区，不是标准化的，甚至不是唯一的（！）。

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

应用ZoneId到Instant获得ZonedDateTime。

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

的 LocalDate级表示没有时间一天和不同时区的日期，唯一的价值。我们可以提取LocalDate从ZonedDateTime，有效地消除了时间的日部分。

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

现在，使用isEqual，isBefore和isAfter。

Boolean sameDate = localDate1.isEqual( localDate2 );

看到 此代码在IdeOne.com上实时运行。

Instant1：2017-03-25T04：13：10.971Z | Instant2：2017年3月24日T22：13：10.972Z

zdt1：2017-03-25T00：13：10.971-04：00 [美国/蒙特利尔] | zdt2：2017-03-24T18：13：10.972-04：00 [美国/蒙特利尔]

localDate1：​​2017-03-25 | localDate2：2017-03-24

sameDate：否

关于java.time

该java.time框架是建立在Java 8和更高版本。这些类取代麻烦的老传统日期时间类，如java.util.Date，Calendar，和SimpleDateFormat。

现在处于维护模式的Joda-Time项目建议迁移到java.time类。

要了解更多信息，请参见Oracle教程。并在Stack Overflow中搜索许多示例和说明。规格为JSR 310。

在哪里获取java.time类？

• Java SE 8和 SE 9及更高版本
  • 内置的
  • 标准Java API的一部分，具有捆绑的实现。
  • Java 9添加了一些次要功能和修复。
• Java SE 6和 SE 7
  • 很多java.time功能都在ThreeTen- Backport中反向移植到Java 6和7 。
• 安卓系统
  • 该ThreeTenABP项目适应ThreeTen，反向移植（上述）为Android特异性。
  • 请参阅如何使用ThreeTenABP…。

该ThreeTen-额外项目与其他类扩展java.time。该项目为将来可能向java.time添加内容提供了一个试验场。你可能在这里找到一些有用的类，比如Interval，YearWeek，YearQuarter，和更多。

已经提到apache commons-utils：

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

给您仅包含日期的Date对象，没有时间，您可以将其与 Date.compareTo

恐怕没有方法可以比较两个可以称为“简单”或“简单”的日期。

在比较两个精度降低的时间实例时（例如，仅比较日期），必须始终考虑时区如何影响比较。

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

您是否要确定这两个事件是否在各自各自的时区的同一日历日期中发生？或者您是否需要知道两个日期是否在特定时区（例如，UTC或本地TZ）中属于同一日历日期。

一旦弄清了您实际上要比较的内容，就可以在适当的时区中将年月日三倍数进行比较。

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

如果您使用的是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);

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

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
}

这是此博客的解决方案： 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.");

即，您可以看到时差（以毫秒为单位）是否小于一天的长度。

`

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

`

我不知道这是新想法，还是我照做给你看

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

只需结合DAYEAR属性检查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
    }
}

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

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

这将帮助您比较日期而无需考虑时间。

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

    }

使用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

根据此处答案和我的导师指导的另一种简单比较方法

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类！

首先，请注意此操作取决于时区。因此，选择是否要在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.time类

我已更改您的实例字段类型的自由Date来Instant，在Java 8相应的I类承诺要恢复的治疗Date之下。我还添加了一个时区常量。您可以将其设置为ZoneOffset.UTC或ZoneId.of("Europe/Stockholm")或您认为合适的内容（将其设置为ZoneOffsetWorks，因为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，那么声明whena LocalDate并跳过所有转换当然更容易。然后，我们也不必担心时区。

现在假设由于某种原因您不能将when字段声明为an，Instant或者想保留它为老式字段Date。如果仍然可以使用Java 8，只需将其转换为Instant，然后像以前一样进行操作：

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

同样适用于o.when。

没有Java 8？

如果无法使用Java 8，则有两种选择：

1. 使用Calendar或的旧类之一解决它SimpleDateFormat。
2. 使用Java 8日期和时间类的向后移植到Java 6和7，然后按照上述步骤进行操作。我在底部包含一个链接。不要使用JodaTime。撰写建议书的答案时，JodaTime可能是一个不错的建议。但是JodaTime现在处于维护模式，因此ThreeTen backport是一个更好，更可靠的选择。

老式的方式

Adamski的答案向您展示了如何Date使用Calendar该类剥离时间部分。我建议您使用它getInstance(TimeZone)来获取Calendar所需时区的实例。或者，您可以使用乔恩答案下半部分的想法。

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

这是受罗布的回答启发的。

时区依赖性

为什么我们必须选择一个特定的时区？假设我们要比较UTC的两次，分别是3月24日0:00（午夜）和12:00（正午）。如果您在欧洲中部时间（例如欧洲/巴黎）这样做，则它们是3月24日（即同一日期）的凌晨1点和下午1点。在纽约（东部夏令时间），它们是3月23日的20:00和3月24日的8:00，即同一天。因此，您选择哪个时区会有所不同。如果您仅依靠计算机的默认设置，当有人尝试在这个全球化世界中另一个地方的计算机上运行您的代码时，您可能会感到惊讶。

链接

链接到ThreeTen Backport，这是Java 8日期和时间类到Java 6和7的反向端口：http : //www.threeten.org/threetenbp/。

我的主张：

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

使用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   

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

我通过按时间戳比较解决了这个问题：

    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上占用了巨大的空间。大小事项。;）

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

返回此Instant的副本，该副本被截断为指定单位。

例：

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

这对我有用：

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 }

如何DateUtil.daysBetween()。它是Java，它返回一个数字（以天为单位的差）。