如何计算连续签到/登录天数问题

今天同事有个计算连续签到天数的需求, 我帮忙看了下, 做了个简单的实现方式
比如 签到结果是 4月 1, 3, 4, 5, 7, 8 号签到, 那我们很明显用眼睛算得出结果最大的连续签到天数是 3-5, 总共3天
那代码如何实现呢 ?

Talk is cheap, Show you the code.
思路也写在代码里了, 直接运行验证一些效果吧

想了两种思路, 个人比较喜欢 方案一拿 1 0 补位的方式, 因为觉得骚, 嘿嘿
有兴趣就看看吧

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 连续签到天数计算
 * @author yss<br>
 * @version 1.0<br>
 * @createDate 2020/04/28 10:18 <br>
 */
public class MaxUninterruptedDays {

    public static void main(String[] args) throws ParseException {
        // 前提条件, dateList 要先做好排序哦
        List<String> queryFromDB = new ArrayList<>();
        queryFromDB.add("2020-04-01");

        queryFromDB.add("2020-04-03");

        queryFromDB.add("2020-04-11");
        queryFromDB.add("2020-04-12");
        queryFromDB.add("2020-04-13");
        queryFromDB.add("2020-04-14");

        queryFromDB.add("2020-04-20");
        queryFromDB.add("2020-04-21");

        Integer maxUninterruptedDays = getMaxUninterruptedDays(queryFromDB);
        System.out.println(maxUninterruptedDays);

        Integer maxUninterruptedDaysByOneZero = getMaxUninterruptedDaysByOneZero(queryFromDB);
        System.out.println(maxUninterruptedDaysByOneZero);
    }

    /**
     * 获取不中断的最大连续天数
     * 思路 1:
     * 签到代表1,签到中断代表0,将整个签到数据拼接成一个10111011这样的字符串,
     * 然后以'0'切割字符串得到一个字符串数组,
     * 后面再计算最长字符串就得到最大连续天数了
     *
     * 循环遍历,将签到的日期拿 1 来补位代表有签到, 如果下一个签到日期不是当前签到日期的下一天,那 用 0 补位,代表签到中断过
     * 举个例子
     * 签到数据
     * 1   3 4 5   7 8   19 20
     * 那我们要得到的一个字符串是
     * 1 0 1 1 1 0 1 1 0 1  1
     * @param dateList
     * @return
     * @throws ParseException
     */
    private static Integer getMaxUninterruptedDaysByOneZero(List<String> dateList) throws ParseException {
        StringBuilder sb = new StringBuilder();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

        for (int i = 0; i < dateList.size(); i++) {

            Date currentItem = dateFormat.parse(dateList.get(i));
            sb.append("1");
            Date nextItem = null;
            // 如果到最后一项了那下一项就是当前项了
            if ((i + 1) == dateList.size()) {
                nextItem = currentItem;
            } else {
                nextItem = dateFormat.parse(dateList.get(i + 1));
            }

            Calendar calendar = Calendar.getInstance();
            calendar.setTime(currentItem);
            calendar.add(Calendar.DATE, 1);
            Date nextDay = calendar.getTime();

            // 如果nextDay不等于nextItem, 代表签到中断, 拿 0 补位 (中断多少天其实咱们不关心)
            if (nextItem.compareTo(nextDay) != 0 && i < dateList.size() -1) {
                sb.append("0");
            }
        }
        System.out.println(sb);
        // 取最大天数
        String s = Arrays.stream(sb.toString().split("0")).max(Comparator.naturalOrder()).get();
        return s.length();
    }

    /**
     * 获取不中断的最大连续天数
     * 思路 2:
     * 将连续的天数作为一个计算单位(begin-end)
     * 当前天的下一天和下一个元素不相等,天数中断
     * 拿数字来打个比方, 1 3 4 5 7 8 10 号签到
     * 结果会分为 (1-1), (3-5), (7-8), (10-10) 这几个计算单位
     *
     * 最终得到的结果是 (begin-end)的差的列表, 排个序就取到连续的最大值了
     * 前提,dateList 要先做好升序处理
     * @param dateList
     * @return
     * @throws ParseException
     */
    private static Integer getMaxUninterruptedDays(List<String> dateList) throws ParseException {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date startDate = dateFormat.parse(dateList.get(0));
        Date endDate = null;

        boolean interrupt = false;

        // tempList是为了查看计算中间结果, 方便检查程序正确性,确认程序的正确性之后即可删除
        List<Map<String, Object>> tempList = new ArrayList<>();

        List<Integer> uninterruptedDays = new ArrayList<>();
        for (int i = 0; i < dateList.size(); i++) {
            if (interrupt) {
                startDate = dateFormat.parse(dateList.get(i));
                interrupt = false;
            }
            Date currentItem = dateFormat.parse(dateList.get(i));
            Date nextItem = null;
            // 如果到最后一项了那下一项就是当前项了
            if ((i + 1) == dateList.size()) {
                nextItem = currentItem;
            } else {
                nextItem = dateFormat.parse(dateList.get(i + 1));
            }

            Calendar calendar = Calendar.getInstance();
            calendar.setTime(currentItem);
            calendar.add(Calendar.DATE, 1);
            Date nextDay = calendar.getTime();

            // 如果nextDay不等于nextItem或者到未元素了,结束日期等于currentDay
            if (nextItem.compareTo(nextDay) != 0 || (i + 1) == dateList.size()) {
                endDate = currentItem;
                uninterruptedDays.add(daysBetween(startDate, endDate));

                Map<String, Object> beginEndItem = new HashMap<>();
                beginEndItem.put("begin", dateFormat.format(startDate));
                beginEndItem.put("end", dateFormat.format(endDate));
                beginEndItem.put("count", daysBetween(startDate, endDate));
                tempList.add(beginEndItem);

                startDate = nextItem;
                interrupt = true;
            }
        }

        System.out.println(tempList);

        // 排序
        Collections.sort(uninterruptedDays);
        // 取最大天数
        return uninterruptedDays.get(uninterruptedDays.size() - 1);
    }


    /**
     * 计算两天之间有几天,这个算法可能不太准确,跟进情况调整
     * @param startDate
     * @param endDate
     * @return
     */
    public static int daysBetween(Date startDate, Date endDate) {
        int days = (int) ((endDate.getTime() - startDate.getTime()) / (1000 * 3600 * 24));
        return days + 1;
    }

}