Java 在Android中计算两个日期之间的周数

如何计算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（不同周）。

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

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

public int getWeekDifference（从DateinMills到DateinMills的长度）{
int weeks=weeks.weeksBetween（新日期时间（fromDateInMills），新日期时间（toDateInMills））.getWeeks（）；
//当我们选择任何未来日期时，周差为负值，因此
//只要交换毫秒，你就会得到周差的正值
如果（周<0）{
weeks=weeks.weeksBetween（新日期时间（toDateInMills），新日期时间（fromDateInMills））.getWeeks（）；
}
返回周；
}

在不使用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")
    }
}

EnumberOfWeeks（）的私人娱乐{
val calendarFrom=Calendar.getInstance（）
calendarFrom.set（Calendar.HOUR\u OF_DAY，0）
calendarFrom.set（Calendar.MINUTE，0）
calendarFrom.set（Calendar.SECOND，0）
calendarFrom.set（Calendar.毫秒，0）
val calendarTo=Calendar.getInstance（）
calendarTo.add（Calendar.MONTH，months）
calendarTo.set（Calendar.HOUR\u OF_DAY，0）
calendarTo.set（Calendar.MINUTE，0）
calendarTo.set（Calendar.SECOND，0）
calendarTo.set（Calendar.毫秒，0）
var weeks=-1
while（calendarFrom.timeInMillis

我建议您不要以周为单位计算差值，而应该尝试以天为单位计算差值，结果可以除以7

因此，使用Java8将是weeks=（Daysbetween Dates/7）

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

    }

---

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

从每个日期算起，您都有一年中的一周。此外，还应列出每个项目的年数。 将每年的数字乘以52，将其加到每年的第周，然后减去这两个数字。 例如 2018年第50周 到 2019年第2周

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

---

104990-104986=4周

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

它可以正确处理边缘情况，如

2000-01-01到2000-12-31

（54周意味着差异53）

使用日历API的getWeeksBetween（）

public static int getWeeksBetween（最终日期开始，最终日期结束）{
最终日历c1=Calendar.getInstance（Locale.US）；
最终日历c2=Calendar.getInstance（Locale.US）；
//跳过时间部分！不确定是否需要，但我想要干净的日期。
CalendarUtils.setDateWithNoTime（c1，开始）；
CalendarUtils.setDateWithNoTime（c2，结束）；
CalendarUtils.goToFirstDayOfWeek（c1）；
CalendarUtils.goToFirstDayOfWeek（c2）；
整数周=0；
而（c1.与（c2）相比<0）{
c1.添加（日历周/年，1）；
周++；
}
返回周；
}

以及一些辅助方法：

公共静态int goToFirstDayOfWeek（最终日历）{
final int firstDayOfWeek=calendar.getFirstDayOfWeek（）；
calendar.set（calendar.DAY，周中第一天，周中第一天）；
星期一返回；
}
公共静态void setDateWithNoTime（最终日历，最终日期）{
日历。设置时间（日期）；
净空时间（日历）；
}
公共静态无效清除时间（最终日历）{
calendar.set（calendar.HOUR\u OF_DAY，0）；
calendar.set（calendar.MINUTE，0）；
calendar.set（calendar.SECOND，0）；
calendar.set（calendar.毫秒，0）；
}

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

将给定日期修剪为相应的星期一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)

---

周六到周日是一天，但不同的一周，所以是一周吗？周日到周六相隔6天，但是同一周，所以是0周吗？@Andreas这是正确的如果添加第三方库不是问题，您可以使用JodaTime完成这一点。看看这个答案：只要得到两个日期之间的天数，然后除以7。检查余数，如果代码中的商//有+1，只需添加这一行，您将得到周差int weeks=weeks.weeksBetween（fromDateTime，toDateTime）.getWeeks（）；

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)