Java 两个日期之间的天数

我想比较我的Android应用程序的两个日期，但我遇到了一个非常奇怪的问题

例如：

如果我将

设置回过去的日期

为127天前：

this.dateEvent = System.currentTimeMillis() - (127 * 24 * 3600 * 1000)

然后将其与当前日期（两天之间）进行比较

它将返回22，这完全不是预期的结果

---

我是否做错了什么，或者这是

日历

类的问题？

请参考此代码，这可能会对您有所帮助

public String getCountOfDays(String createdDateString, String expireDateString) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy", Locale.getDefault());

    Date createdConvertedDate = null, expireCovertedDate = null, todayWithZeroTime = null;
    try {
        createdConvertedDate = dateFormat.parse(createdDateString);
        expireCovertedDate = dateFormat.parse(expireDateString);

        Date today = new Date();

        todayWithZeroTime = dateFormat.parse(dateFormat.format(today));
    } catch (ParseException e) {
        e.printStackTrace();
    }

    int cYear = 0, cMonth = 0, cDay = 0;

    if (createdConvertedDate.after(todayWithZeroTime)) {
        Calendar cCal = Calendar.getInstance();
        cCal.setTime(createdConvertedDate);
        cYear = cCal.get(Calendar.YEAR);
        cMonth = cCal.get(Calendar.MONTH);
        cDay = cCal.get(Calendar.DAY_OF_MONTH);

    } else {
        Calendar cCal = Calendar.getInstance();
        cCal.setTime(todayWithZeroTime);
        cYear = cCal.get(Calendar.YEAR);
        cMonth = cCal.get(Calendar.MONTH);
        cDay = cCal.get(Calendar.DAY_OF_MONTH);
    }


    /*Calendar todayCal = Calendar.getInstance();
    int todayYear = todayCal.get(Calendar.YEAR);
    int today = todayCal.get(Calendar.MONTH);
    int todayDay = todayCal.get(Calendar.DAY_OF_MONTH);
    */

    Calendar eCal = Calendar.getInstance();
    eCal.setTime(expireCovertedDate);

    int eYear = eCal.get(Calendar.YEAR);
    int eMonth = eCal.get(Calendar.MONTH);
    int eDay = eCal.get(Calendar.DAY_OF_MONTH);

    Calendar date1 = Calendar.getInstance();
    Calendar date2 = Calendar.getInstance();

    date1.clear();
    date1.set(cYear, cMonth, cDay);
    date2.clear();
    date2.set(eYear, eMonth, eDay);

    long diff = date2.getTimeInMillis() - date1.getTimeInMillis();

    float dayCount = (float) diff / (24 * 60 * 60 * 1000);

    return ("" + (int) dayCount + " Days");
}

---

我也有同样的需求，我最终使用了Joda Time，它非常方便，并提供了许多附加功能，包括您正在寻找的功能

您可以从下载文件

将jar文件包含到项目中后，您可以轻松地执行以下操作，例如：

int daysBetween = Days.daysBetween(new DateTime(sDate), new DateTime(eDate)).getDays();

---

我终于找到了解决这个问题的最简单方法。这是我的密码：

public int getTimeRemaining()
{
    Calendar sDate = toCalendar(this.dateEvent);
    Calendar eDate = toCalendar(System.currentTimeMillis());

    // Get the represented date in milliseconds
    long milis1 = sDate.getTimeInMillis();
    long milis2 = eDate.getTimeInMillis();

    // Calculate difference in milliseconds
    long diff = Math.abs(milis2 - milis1);

    return (int)(diff / (24 * 60 * 60 * 1000));
}

private Calendar toCalendar(long timestamp)
{
    Calendar calendar = Calendar.getInstance();
    calendar.setTimeInMillis(timestamp);
    calendar.set(Calendar.HOUR_OF_DAY, 0);
    calendar.set(Calendar.MINUTE, 0);
    calendar.set(Calendar.SECOND, 0);
    calendar.set(Calendar.MILLISECOND, 0);
    return calendar;
}

希望有帮助。

最好的方法：-

        long fromCalender = Calender.getInstance();
        fromCalender.set...// set the from dates
        long toCalender = Calender.getInstance();
        fromCalender.set...// set the to dates

        long diffmili = fromCalender - toCalender;

        long hours = TimeUnit.MILLISECONDS.toHours(diffmili);
        long days = TimeUnit.MILLISECONDS.toDays(diffmili);
        long min = TimeUnit.MILLISECONDS.toMinutes(diffmili);
        long sec = TimeUnit.MILLISECONDS.toSeconds(diffmili);

---

以下是一个两行解决方案：

long msDiff = Calendar.getInstance().getTimeInMillis() - testCalendar.getTimeInMillis();
long daysDiff = TimeUnit.MILLISECONDS.toDays(msDiff);

---

在本例中，它获取日期“testCalendar”和当前日期之间的天数。

对我有效的最佳解决方案是：

    Date userDob = new SimpleDateFormat("yyyy-MM-dd").parse(dob);
    Date today = new Date();
    long diff =  today.getTime() - userDob.getTime();
    int numOfYear = (int) ((diff / (1000 * 60 * 60 * 24))/365);
    int numOfDays = (int) (diff / (1000 * 60 * 60 * 24));
    int hours = (int) (diff / (1000 * 60 * 60));
    int minutes = (int) (diff / (1000 * 60));
    int seconds = (int) (diff / (1000));

private static int findDaysDiff(long unixStartTime,long unixEndTime)
    {
        Calendar calendar1 = Calendar.getInstance();
        calendar1.setTimeInMillis(unixStartTime);
        calendar1.set(Calendar.HOUR_OF_DAY, 0);
        calendar1.set(Calendar.MINUTE, 0);
        calendar1.set(Calendar.SECOND, 0);
        calendar1.set(Calendar.MILLISECOND, 0);

        Calendar calendar2 = Calendar.getInstance();
        calendar2.setTimeInMillis(unixEndTime);
        calendar2.set(Calendar.HOUR_OF_DAY, 0);
        calendar2.set(Calendar.MINUTE, 0);
        calendar2.set(Calendar.SECOND, 0);
        calendar2.set(Calendar.MILLISECOND, 0);

        return (int) ((calendar2.getTimeInMillis()-calendar1.getTimeInMillis())/(24 * 60 * 60 * 1000));

    }

---

由于它首先将

小时

、

分钟

、

秒

和

毫秒

转换为

0

，现在的差异仅以天为单位

你不应该使用24*60*60*1000这样的公式！为什么？因为可以节省一天的时间，而且不是所有的日子都有24小时，闰年也有+1天。这就是为什么有一个日历类。 如果您不想将任何外部库（如Jodatime）放入项目中，则可以使用具有非常高效功能的纯日历类：

public static int numDaysBetween(final Calendar c, final long fromTime, final long toTime) {
    int result = 0;
    if (toTime <= fromTime) return result;

    c.setTimeInMillis(toTime);
    final int toYear = c.get(Calendar.YEAR);
    result += c.get(Calendar.DAY_OF_YEAR);

    c.setTimeInMillis(fromTime);
    result -= c.get(Calendar.DAY_OF_YEAR);

    while (c.get(Calendar.YEAR) < toYear) {
        result += c.getActualMaximum(Calendar.DAY_OF_YEAR);
        c.add(Calendar.YEAR, 1);
    }

    return result;
}

public static int numDaysBetween（最终日历c、最终long fromTime、最终long toTime）{
int结果=0；
如果（toTime在某些日期，如“2019/02/18”、“2019/02/19”，答案不正确，但我编辑并解决了错误

这是最好的方法：

 public int getCountOfDays(String createdDateString, String expireDateString) {

        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

        Date createdConvertedDate = null;
        Date expireCovertedDate = null;
        try {
            createdConvertedDate = dateFormat.parse(createdDateString);
            expireCovertedDate = dateFormat.parse(expireDateString);
        } catch (ParseException e) {
            e.printStackTrace();
        }


        Calendar start = new GregorianCalendar();
        start.setTime(createdConvertedDate);

        Calendar end = new GregorianCalendar();
        end.setTime(expireCovertedDate);

        long diff = end.getTimeInMillis() - start.getTimeInMillis();

        float dayCount = (float) diff / (24 * 60 * 60 * 1000);


        return (int) (dayCount);
    }

享受，如果有帮助，请投票给这个答案；）
这样做它支持所有Api级别

    Calendar cal = Calendar.getInstance();
    SimpleDateFormat sdf = new SimpleDateFormat("MMM dd yyyy HH:mm:ss", 
    Locale.ENGLISH);
    try {
        String datestart="June 14 2018 16:02:37";
        cal.setTime(sdf.parse(datestart));// all done
         Calendar cal1=Calendar.getInstance();
        String formatted = sdf.format(cal1.getTime());//formatted date as i want
        cal1.setTime(sdf.parse(formatted));// all done

        long msDiff = cal1.getTimeInMillis() - cal.getTimeInMillis();
        long daysDiff = TimeUnit.MILLISECONDS.toDays(msDiff);
        Toast.makeText(this, "days="+daysDiff, Toast.LENGTH_SHORT).show();
    } catch (ParseException e) {
        e.printStackTrace();
    }

试一试：

    val f = SimpleDateFormat("yyyy-MM-dd HH:mm:ss").apply {
        timeZone = TimeZone.getTimeZone("GMT")
    }
    val df = f.parse("2019-02-28 22:59:59")
    val dt = f.parse("2019-02-28 23:00:00")

    TimeZone.getTimeZone("GMT").daysBetween(df, dt)  // 0
    TimeZone.getTimeZone("GMT+1").daysBetween(df, dt) // 1

我正在计算上次提交日期和当前日期之间的天数，如果小于零，则学生无法提交。我正在与kotlin合作。下面的代码帮助您

 var calendar=Calendar.getInstance().time
 var dateFormat= SimpleDateFormat("dd/M/yyyy")
 var d2=dateFormat.parse(data.get("date").toString())
 var cd=dateFormat.format(calendar)
 var d1=dateFormat.parse(cd)
 var diff=d2.time-d1.time
 var ddd= TimeUnit.DAYS.convert(diff, TimeUnit.MILLISECONDS)

java.time和ThreeTenABP
我想提供一个现代的答案：使用java.time，这是一个现代的java日期和时间API，用于约会工作。如果是为Android API级别25或更低的开发，那么通过Android的后端口ThreeTenABP（底部的链接）

当我今天运行这段代码时，输出是预期的：

127

请注意，代码不仅较短，只有一行用于查找差异；它还更清晰、更自然。您使用的类
Date
和
Calendar
设计不良且过时很久。我建议您不要使用它们

你的代码出了什么问题？
在127天到毫秒的转换过程中，出现了
int
溢出。在数学中，127*24*3600*1000等于10972800000。由于所乘的数字是
int
s，Java在
int
中执行乘法，而
int
所能容纳的最大数字是2147483647，远远不够f或者您预期的结果。在这种情况下，如果Java会抛出异常或以其他方式让我们知道错误，那就太好了。它不会。它会默认地丢弃高阶位，给我们一个-1 912 101 888的结果。从当前时间中减去这个负数相当于加上22天和一个几个小时。这就解释了为什么你得到了22个答案。有趣的是，13个答案已经发布了，而且似乎没有人发现这个

即使使用
long
类型进行乘法运算，它仍然无法正确计算127天。如果127天与夏季时间（DST）过渡，在法国，一年365天中有254天是这样，过渡的日期不是24小时，而是23或25。这会导致毫秒数不正确

你应该始终将日期数学留给经过验证的库方法。永远不要自己手工编写。它比我们大多数人想象的要复杂，因此错误地编写它的风险很高

问：java.time不需要Android API级别26吗？
java.time在较旧和较新的Android设备上都能很好地工作。它至少需要Java6


在Java8和更高版本以及更新的Android设备上（API级别26），现代API是内置的
在非androidjava6和7中，获取三个后端口，即现代类的后端口（三个十用于jsr310；请参见底部的链接）
在（较旧的）Android上，使用Android版的ThreeTen Backport。它被称为ThreeTenABP。并确保您使用子包从
org.ThreeTen.bp
导入日期和时间类

链接

解释如何使用java.time
，其中首先描述了
java.time
，java.time的后端口

到Java6和Java7（JSR-310为三十）

，Android版Three Ten Backport

，解释得非常透彻

---

这是Java 8 Java.time版本，对我来说非常适合。您可能需要确保startDate和endDate设置为相同的时间，否则天数可能会因

+-1

而变化！ 这些是我刚刚复制/粘贴的Kotlin版本

private fun getDawnOfDay(instant: Instant): Temporal =
        LocalDate.from(instant.atZone(ZoneOffset.UTC)).atStartOfDay()

fun getNumberOfDaysInBetween(startDate: Date, endDate: Date) =
        Duration.between(getDawnOfDay(startDate.toInstant()), getDawnOfDay(endDate.toInstant()))
            .toDays()

---

Kotlin扩展名：

fun Date?.getDaysBetween(dest: Date?): Int {

    if(this == null || dest == null) return 0

    val diff = abs(this.time - dest.time)
    val dayCount = diff.toFloat() / (24 * 60 * 60 * 1000)
    return dayCount.toInt()
}

---

我刚刚修改了一点最流行的答案。 以下是我的解决方案： daysBetween（）-返回两个日期之间的天数计数

public static long daysBetween(Date date1, Date date2) {
        long msDiff = resetTimeToDateStart(date1).getTime() - resetTimeToDateStart(date2).getTime();
        return TimeUnit.MILLISECONDS.toDays(msDiff);
    }
private static Date resetTimeToDateStart(Date dDate){
        if (Utils.isNull(dDate)){
            return null;
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(dDate);
        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();
    }

---

dateEvent

的声明是什么样子的？您总是添加每月的第天（因此，在31、30、28或29日之后，它将从1开始计数），而不是第天。在第一种情况下，我会添加一个负数（-1）您好，

dateEvent

是用

private long dateEvent=0L；

声明的

    LocalDate eDate = LocalDate.now(ZoneId.of("Europe/Paris"));
    LocalDate sDate = eDate.minusDays(127);

    long daysBetween = ChronoUnit.DAYS.between(sDate, eDate);
    System.out.println(daysBetween);

private fun getDawnOfDay(instant: Instant): Temporal =
        LocalDate.from(instant.atZone(ZoneOffset.UTC)).atStartOfDay()

fun getNumberOfDaysInBetween(startDate: Date, endDate: Date) =
        Duration.between(getDawnOfDay(startDate.toInstant()), getDawnOfDay(endDate.toInstant()))
            .toDays()

fun Date?.getDaysBetween(dest: Date?): Int {

    if(this == null || dest == null) return 0

    val diff = abs(this.time - dest.time)
    val dayCount = diff.toFloat() / (24 * 60 * 60 * 1000)
    return dayCount.toInt()
}

public static long daysBetween(Date date1, Date date2) {
        long msDiff = resetTimeToDateStart(date1).getTime() - resetTimeToDateStart(date2).getTime();
        return TimeUnit.MILLISECONDS.toDays(msDiff);
    }
private static Date resetTimeToDateStart(Date dDate){
        if (Utils.isNull(dDate)){
            return null;
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(dDate);
        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();
    }

int difference in days=(present_year - oldyear) * 365 + (present_month - oldmonth)*30 + (present_date-olddate);