计算Android中两个日期之间的周数答案

【问题标题】：Calculating the number of weeks between two dates in Android计算Android中两个日期之间的周数
【发布时间】：2016-12-18 17:18:24
【问题描述】：

如何计算 Android 中两个日期之间的周数？我做过这样的事情

int week1 = calendar1.get(Calendar.WEEK_OF_YEAR);
int week2 = calendar2.get(Calendar.WEEK_OF_YEAR);
int calendarWeekDifference = week2 - week1;

但是，当两个日期在不同年份时，这不起作用。我怎样才能实现一个解决方案，以便它可以跨越不同的年份？

编辑

我已尝试使用 Joda-Time 执行以下操作：

public static int weeksTouched(Calendar fromDate, Calendar toDate){
    DateTime fromDateTime = new DateTime(fromDate);
    DateTime toDateTime = new DateTime(toDate);
    DateTime epoch = new DateTime(0);
    Weeks fromWeeks = Weeks.weeksBetween(epoch, fromDateTime);
    Weeks toWeeks = Weeks.weeksBetween(epoch, toDateTime);
    int betweenWeeks = toWeeks.getWeeks() - fromWeeks.getWeeks();
    return betweenWeeks;
}

这几乎可行，但由于某种原因，它认为一周的开始是星期四。我希望一周的开始是星期一，这样星期一到下星期六将返回 0（同一周），但星期六到下一天星期日将返回 1（不同的星期）。

【问题讨论】：

周六到周日是 1 天，但一周不同，那是 1 周吗？周日到周六相隔 6 天，但同一周，那是 0 周吗？
@Andreas 没错
如果添加第三方库不是问题，您可以使用 JodaTime 完成此操作。看看这个答案：stackoverflow.com/a/24265259/4872155
只需获取两个日期之间的天数，然后将其除以 7。然后检查余数，如果商有 +1 则

标签： java android datetime

【解决方案1】：

public int getWeekDifference(long fromDateInMills, long toDateInMills) {

    int weeks = Weeks.weeksBetween(new DateTime(fromDateInMills), new DateTime(toDateInMills)).getWeeks();

    // when we select any future date than week difference comes in negative so
    // just interchange millisecond You will get week difference in positive
    if (weeks < 0) {
        weeks = Weeks.weeksBetween(new DateTime(toDateInMills), new DateTime(fromDateInMills)).getWeeks();
    }

    return weeks;

}

【讨论】：

// 在您的代码中添加这一行，您将获得周差 int week = Weeks.weeksBetween(fromDateTime, toDateTime).getWeeks();

【解决方案2】：

这里有些答案给出了错误的结果，有些需要额外的库。我设法提出了一种使用标准 Calendar API 计算周差异的方法。

它可以正确处理像 2000-01-01 to 2000-12-31 这样的边缘情况（54 周意味着相差 53 周）。

getWeeksBetween() 使用日历 API

public static int getWeeksBetween(final Date start, final Date end) {
    final Calendar c1 = Calendar.getInstance(Locale.US);
    final Calendar c2 = Calendar.getInstance(Locale.US);

    // Skip time part! Not sure if this is needed, but I wanted clean dates.
    CalendarUtils.setDateWithNoTime(c1, start);
    CalendarUtils.setDateWithNoTime(c2, end);

    CalendarUtils.goToFirstDayOfWeek(c1);
    CalendarUtils.goToFirstDayOfWeek(c2);

    int weeks = 0;
    while (c1.compareTo(c2) < 0) {
        c1.add(Calendar.WEEK_OF_YEAR, 1);
        weeks++;
    }

    return weeks;
}

还有一些辅助方法：

public static int goToFirstDayOfWeek(final Calendar calendar) {
    final int firstDayOfWeek = calendar.getFirstDayOfWeek();
    calendar.set(Calendar.DAY_OF_WEEK, firstDayOfWeek);

    return firstDayOfWeek;
}

public static void setDateWithNoTime(final Calendar calendar, final Date date) {
    calendar.setTime(date);
    clearTime(calendar);
}

public static void clearTime(final Calendar calendar) {
    calendar.set(Calendar.HOUR_OF_DAY, 0);
    calendar.set(Calendar.MINUTE, 0);
    calendar.set(Calendar.SECOND, 0);
    calendar.set(Calendar.MILLISECOND, 0);
}

【讨论】：

【解决方案3】：

没有使用 JodaTime，我想出了这个计算周数的解决方案：

private fun calculateNumberOfWeeks() {
    val calendarFrom = Calendar.getInstance()
    calendarFrom.set(Calendar.HOUR_OF_DAY, 0)
    calendarFrom.set(Calendar.MINUTE, 0)
    calendarFrom.set(Calendar.SECOND, 0)
    calendarFrom.set(Calendar.MILLISECOND, 0)

    val calendarTo = Calendar.getInstance()
    calendarTo.add(Calendar.MONTH, months)
    calendarTo.set(Calendar.HOUR_OF_DAY, 0)
    calendarTo.set(Calendar.MINUTE, 0)
    calendarTo.set(Calendar.SECOND, 0)
    calendarTo.set(Calendar.MILLISECOND, 0)

    var weeks = -1
    while (calendarFrom.timeInMillis < calendarTo.timeInMillis) {
        calendarFrom.add(Calendar.DATE, 7)
        weeks++
        Log.d(Constants.LOG_TAG, "weeks $weeks")
    }
}

【讨论】：

【解决方案4】：

我建议不要以周为单位计算差异，而应尝试找出天数的差异，然后除以 7。

所以应该是几周 = (daysBetweenDates / 7)

【讨论】：

【解决方案5】：

使用 java 8

public void weeks_between_two_dates_in_java_with_java8 () {

    LocalDate startDate = LocalDate.of(2005, Month.JANUARY, 1);
    LocalDate endDate = LocalDate.of(2006, Month.JANUARY, 1);

    long weeksInYear = ChronoUnit.WEEKS.between(startDate, endDate);

   }

或者使用joda time api

public void weeks_between_two_dates_in_java_with_joda () {

    DateTime start = new DateTime(2005, 1, 1, 0, 0, 0, 0);
    DateTime end = new DateTime(2006, 1, 1, 0, 0, 0, 0);

    Weeks weeks = Weeks.weeksBetween(start, end);

    int weeksInYear = weeks.getWeeks();

    }

【讨论】：

【解决方案6】：

仅使用数学的一种低技术解决方案怎么样？

您拥有每个日期的 Week_OF_YEAR。还有每个年份的编号。将每个年份数字乘以 52，将其添加到 WEEK_OF_YEAR，然后减去这两个数字。例如.... 2018 第 50 周至 2019 年第 2 周

2018*52 = 104936 + 50 周 = 104986
2019*52 = 104988 + 2 周 = 104990

104990 - 104986 = 4 周

【讨论】：

【解决方案7】：

另一种替代解决方案。我的基本概念是：

将给定日期修剪为相应的星期一 00:00:00.000
计算这些修剪日期之间的毫秒数，然后除以一周的毫秒数。

Java 示例：

public class Main {
    
    public static void main(String[] args) {
        Calendar Monday = Calendar.getInstance();
        Monday.set(2020, 11, 28, 12, 34, 56); // 2020-12-28T12:34:56
        Calendar Saturday = Calendar.getInstance();
        Saturday.set(2021, 0, 2, 21, 43, 57); // 2021-01-02T21:43:57
        Calendar Sunday = Calendar.getInstance();
        Sunday.set(2021, 0, 3, 0, 1, 2); // 2021-01-03T00:01:02
        Calendar NextMonday = Calendar.getInstance();
        NextMonday.set(2021, 0, 4, 1, 23, 45); // 2021-01-04T01:23:45
        
        System.out.println(String.format(": %d week(s)", weeksTouched(Monday, Sunday)));
        System.out.println(String.format(": %d week(s)", weeksTouched(Saturday, Sunday)));
        System.out.println(String.format(": %d week(s)", weeksTouched(Sunday, NextMonday)));
    }
    
    public static int weeksTouched(Calendar fromDate, Calendar toDate){
        System.out.print(String.format("%s -> %s", fromDate.getTime(), toDate.getTime()));
        return (int) (
                (trimToMonday(toDate).getTimeInMillis() - trimToMonday(fromDate).getTimeInMillis())
                / (1000 * 60 * 60 * 24 * 7)
                );
    }
    
    private static Calendar trimToMonday(Calendar input) {
        Calendar output = (Calendar) input.clone();
        
        switch (output.get(Calendar.DAY_OF_WEEK)) {
        case Calendar.TUESDAY:
            output.add(Calendar.DAY_OF_MONTH, -1);
            break;
        case Calendar.WEDNESDAY:
            output.add(Calendar.DAY_OF_MONTH, -2);
            break;
        case Calendar.THURSDAY:
            output.add(Calendar.DAY_OF_MONTH, -3);
            break;
        case Calendar.FRIDAY:
            output.add(Calendar.DAY_OF_MONTH, -4);
            break;
        case Calendar.SATURDAY:
            output.add(Calendar.DAY_OF_MONTH, -5);
            break;
        case Calendar.SUNDAY:
            output.add(Calendar.DAY_OF_MONTH, -6);
            break;
        }
        
        output.set(Calendar.HOUR_OF_DAY, 0);
        output.set(Calendar.MINUTE, 0);
        output.set(Calendar.SECOND, 0);
        output.set(Calendar.MILLISECOND, 0);
        
        return output;
    }
}

输出：

Mon Dec 28 12:34:56 JST 2020 -> Sun Jan 03 00:01:02 JST 2021: 0 week(s)
Sat Jan 02 21:43:57 JST 2021 -> Sun Jan 03 00:01:02 JST 2021: 0 week(s)
Sun Jan 03 00:01:02 JST 2021 -> Mon Jan 04 01:23:45 JST 2021: 1 week(s)

【讨论】：

【解决方案8】：

这将为您提供两个日期的周数。

  public void getNoOfWeek()
    {

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

        date1.clear();
        date1.set(2015, 12, 29); // set date 1 (yyyy,mm,dd)
        date2.clear();
        date2.set(2016, 02, 7); //set date 2 (yyyy,mm,dd)

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

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

        int week = (int) (dayCount / 7);
        System.out.println(week);
    }

【讨论】：