实现思路
/**
     * 是否连续n天出现，实现逻辑：指定时间段，获取该时间段内检索结果，根据时间段判断是否连续出现
     * @param results
     * [
     *     {
     *         "record": {
     *             "createTime": "2020-06-17T09:13:00.051Z",
     *             "id": "xxxxxxxxx",
     *         },
     *         "money": 22
     *     }
     * ]
     * 计算逻辑解释：假设有4条分别在前1，2，3，3天出现，则每天命中值为1<<1, 1<<2, 1<<3, 1<<3, 判断是否在前3天连续出现，
     * 只需将每条记录的命中值联合取|，即2,4,8,8一起取| => 2|4|8|8，判断其结果与(2^3)-1是否相等即可。相等则连续，不等则非连续
     *
     * @return
     */
    private boolean checkContinuousAppear(List<User> results) {
        if (CollectionUtils.isEmpty(results)) {
            throw new IllegalArgumentException("user results can't be null or empty!");
        }
        List<Integer> hitsCollection = results.stream().map(e -> hitBit(e.getRecord().getCreateTime())).collect(Collectors.toList());
        Integer result = hitsCollection.stream().reduce((x1, x2) -> x1 | x2).get();
        if (result.equals((1 << bizConfig.getContinuousOccurDays()) - 1)) {
            return true;
        }
        return false;
    }

    /**
     * 使用移位记录每个时间点是否命中
     * 1 2 4 8 16 32 .....
     *
     * @param time
     * @return
     */
    private int hitBit(Instant time) {
        LocalDate beforeNDate = LocalDate.now().minusDays(bizConfig.getContinuousOccurDays());
        for (int i = 0; i < bizConfig.getContinuousOccurDays(); i++) {
            Instant start, end;
            if (i == 0) {
                start = beforeNDate.atStartOfDay().toInstant(ZoneOffset.UTC);
            } else {
                start = beforeNDate.plusDays(i).atStartOfDay().toInstant(ZoneOffset.UTC);
            }
            end = beforeNDate.plusDays(i + 1).atStartOfDay().toInstant(ZoneOffset.UTC);
            if (hitTime(time, start, end)) {
                return 1<< i;
            }
        }
        return 1;
    }
/**
     * 判断给定时间是否在时间区间内
     * @param target
     * @param start
     * @param end
     * @return
     */
    private boolean hitTime(Instant target, Instant start, Instant end) {
        if (target.toEpochMilli() >= start.toEpochMilli() && target.toEpochMilli() <= end.toEpochMilli()) {
            return true;
        }
        return false;
    }

此逻辑同样可推广至最近n小时，n分钟，n秒之类的判断

判断一串数值之间是不是连续
	isContinuityNum(num){  //判断选中的时间段是否连续
				let array=[];
				if(num instanceof Array){
					array = [...num];
				}else{
					array = Array.from(num.toString())//转换为数组
				}            
				array.sort(function(a,b){   //要做一下排序,不然如果顺序颠倒过来就无法判断数值是否连续了
					return a- b;
				});
				var i=array[0];
				var isContinuation=true;
				for(var e in array){
						if(array[e]!=i){
								isContinuation=false;
								break;
						}
						i++;
				}
				return isContinuation;
		},

hql统计连续登录三天及以上的用户
数据提供
 用户ID、登入日期
 user01,2018-02-28
 user01,2018-03-01
 user01,2018-03-02
 user01,2018-03-04
 user01,2018-03-05
 user01,2018-03-06
 user01,2018-03-07
 user02,2018-03-01
 user02,2018-03-02
 user02,2018-03-03
 user02,2018-03-06

输出字段
user_id | times | start_date | end_date

创建表
 create table lxdl(
 user_id string comment '用户ID'
 ,login_date date comment '登入日期'
 )
 row format delimited fields terminated by ',';

加载数据
load data local inpath '/opt/module/datas/dsjsfc/user.txt' into table lxdl;

验证数据
select * from lxdl;
+---------------+------------------+--+
| lxdl.user_id  | lxdl.login_date  |
+---------------+------------------+--+
|  user01       | 2018-02-28       |
|  user01       | 2018-03-01       |
|  user01       | 2018-03-02       |
|  user01       | 2018-03-04       |
|  user01       | 2018-03-05       |
|  user01       | 2018-03-06       |
|  user01       | 2018-03-07       |
|  user02       | 2018-03-01       |
|  user02       | 2018-03-02       |
|  user02       | 2018-03-03       |
|  user02       | 2018-03-06       |
+---------------+------------------+--+

思路
1.根据user_id分区,日期排序
select 
	user_id,login_date,
	row_number() over(partition by user_id order by login_date) as rn 
from 
	lxdl;

输出
+-------------+-------------+-------+--+
| user_id     |	login_date	|	rn  |  
+-------------+-------------+-------+--+
| user01	  |	2018-02-28	|	1	|
| user01	  |	2018-03-01	|	2   |
| user01	  |	2018-03-02	|	3	|
| user01	  |	2018-03-04	|	4	|
| user01	  |	2018-03-05	|	5	|
| user01	  |	2018-03-06	|	6	|
| user01	  |	2018-03-07	|	7	|
| user02	  |	2018-03-01	|	1	|
| user02	  |	2018-03-02	|	2	|
| user02	  |	2018-03-03	|	3	|
| user02	  |	2018-03-06	|	4	|
+-------------+-------------+-------+--+

2.用日期与rn想减,得到的差值如果相等,则说明日期是连续的
select 
	user_id,login_date,
	date_sub(login_date,rn) as date_diff 
from 
	(
    select 
		user_id,login_date,
		row_number() over(partition by user_id order by login_date) as rn 
	from 
		lxdl
	) t1;

输出
+-------------+-------------+-------------+--+
| user_id     |	login_date	|  date_diff  |  
+-------------+-------------+-------------+--+
| user01	  |	2018-02-28	| 2018-02-27  |
| user01	  |	2018-03-01	| 2018-02-27  |   
| user01	  |	2018-03-02	| 2018-02-27  |
| user01	  |	2018-03-04	| 2018-02-28  |
| user01	  |	2018-03-05	| 2018-02-28  |
| user01	  |	2018-03-06	| 2018-02-28  |
| user01	  |	2018-03-07	| 2018-02-28  |
| user02	  |	2018-03-01	| 2018-02-28  |
| user02	  |	2018-03-02	| 2018-02-28  |
| user02	  |	2018-03-03	| 2018-02-28  |
| user02	  |	2018-03-06	| 2018-03-02  |
+-------------+-------------+-------------+--+

3.根据user_id和date_diff分组,最小登录日期即为此次连续登录的开始日期start_date,最大登录日期即为结束日期end_date,登录次数即为分组后的count(1)
select 
	user_id,count(1) as times,
	min(login_date) as start_date,
	max(login_date) as end_date
from
	(
        select 
        	user_id,login_date,
        	date_sub(login_date,rn) as date_diff 
        from 
        (
            select 
				user_id,login_date,
				row_number() over(partition by user_id order by login_date) as rn 
			from 
				lxdl) 
        t1) t2 
group by user_id,date_diff 
having times >=3;

输出
+-----------+-----------+----------------+--------------+--+
|	user_id	|	times	|	start_date	 |	end_date   	|
+-----------+-----------+----------------+--------------+--+	
| 	user01	|	3		|	2018-02-28	 |	2018-03-02	|
| 	user01	|	4		|	2018-03-04	 |	2018-03-07	|	
| 	user02	|	3		|	2018-03-01	 |	2018-03-03	|
+-----------+-----------+----------------+--------------+--+

现有一个整数数组，其元素是0-65535之间的任意数字。一直相同数字不会重复出现，而0可以重复出现，且0可以通配任意一个数字。设计一个算法判断该数组中的元素是否连续。

如果一个数组包含n个元素，并且该数组中元素是连续的，那么它一定具有“数组中最大值元素与最小值元素之差为n-1”的性质。如果这些元素中包含0这样的通配数字，并且保证数组中的元素是连续的，那么数组中的非零最大值与非零最小值之差不能超过n-1.

int isContinuousArray(int array[],int len){

int maxVal=array[0],minVal=array[0];

int i;

for(i=1;i<len;i++){

if(array[i]>maxVal&&array[i]!=0)

      maxVal=array[i];

else if(array[i]<minVal&&array[i]!=0){

      minVal=array[i];

      }

}

if(maxVal-minVal>len-1)

      return 0;

else{

     return 1;}

}