Java 日期区间与日期区间集合的差集 代码实现

最新推荐文章于 2024-07-27 04:46:48 发布
最新推荐文章于 2024-07-27 04:46:48 发布
阅读量4.1k 收藏 16
点赞数 4
分类专栏： 工具类 文章标签： 日期区间的差集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hongguo_cheng/article/details/93634245
版权

Java 日期区间与日期区间集合的差集 代码实现

项目中遇到一个需求，就是过滤出一个日期区间与一个日期区间集合的差集。
例如：
已有日期区间：[2019-07-01 00:00:00~2019-07-31 23:59:59]
日期区间集合为：[{2019-07-01 00:00:00, 2019-07-10 23:59:59}, {2019-07-15 00:00:00, 2019-07-20 23:59:59}, {2019-07-22 00:00:00, 2019-07-25 23:59:59}]
目标结果：[{2019-07-11 00:00:00, 2019-07-14 23:59:59}, {2019-07-21 00:00:00, 2019-07-21 23:59:59}, {2019-07-26 00:00:00, 2019-07-31 23:59:59}]

0. 解决思路

  1. 测试数据准备
    1.1 已知日期区间对象 DateObject date
    1.2 初始化日期区间集合 List<DateObject> list
  2. 将日期集合list中的所有日期区间合并
  3. 已知日期区间date与list求交集（找出list中日期区间坐落到date的交集intersection）
    交集
  4. 已知日期区间date再与交集intersection求差集differences
    差集

1. 定义包含[开始日期~结束日期]的对象DateObject

/**
 * 包含开始日期和结束日期的对象
 */
public class DateObject {
    private Date startDate;
    private Date endDate;

    public DateObject(Date startDate, Date endDate) {
        this.startDate = startDate;
        this.endDate = endDate;
    }

    public Date getStartDate() {
        return startDate;
    }

    public void setStartDate(Date startDate) {
        this.startDate = startDate;
    }

    public Date getEndDate() {
        return endDate;
    }

    public void setEndDate(Date endDate) {
        this.endDate = endDate;
    }

    @Override
    public String toString() {
        return "DateObject{startDate=" + startDate + ", endDate=" + endDate +  "}";
    }
}

2. 初始化DateObject集合对象

    /**
     * 初始化DateObject集合对象
     *
     * @return 集合对象
     * @throws Exception 异常
     */
    private List<DateObject> init() throws Exception {
        List<DateObject> list = new ArrayList<>();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        list.add(new DateObject(format.parse("2019-07-01 00:00:00"), format.parse("2019-07-10 23:59:59")));
        list.add(new DateObject(format.parse("2019-07-15 00:00:00"), format.parse("2019-07-20 23:59:59")));
        list.add(new DateObject(format.parse("2019-07-22 00:00:00"), format.parse("2019-07-25 23:59:59")));
        list.sort(Comparator.comparing(DateObject::getStartDate));
        return list;
    }

3. DateObject集合中的日期区间合并

    /**
     * 时间区间合并
     *
     * @param list 日期集合
     * @return 合并后日期集合
     */
    private List<DateObject> merge(List<DateObject> list) {
        if (list == null || list.size() == 0) {
            return new ArrayList<>();
        }

        List<DateObject> result = new ArrayList<>();
        DateObject first = list.get(0);
        for (int i = 1; i < list.size(); i++) {
            DateObject next = list.get(i);
            // 合并区间，时间精确到秒（差1秒则为连续）
            if (next.getStartDate().getTime() < first.getEndDate().getTime() || next.getStartDate().getTime() - first.getEndDate().getTime() == 1000) {
                first.setStartDate(new Date(Math.min(first.getStartDate().getTime(), next.getStartDate().getTime())));
                first.setEndDate(new Date(Math.max(first.getEndDate().getTime(), next.getEndDate().getTime())));
            } else {
                // 没有交集，直接添加
                result.add(first);
                first = next;
            }
        }
        result.add(first);
        return result;
    }

4. 已知日期区间date与日期区间集合list求交集

分析：集合中时间区间遍历与date相比较，两个时间区间会有4中相交的情况，此处只讨论有交集的情况。
两个时间区间相交的情况

   /**
     * 求开放时间区间与时间区间的所有交集
     *
     * @param dateObject 日期对象
     * @param list       日期列表
     * @return 日期交集
     */
    private List<DateObject> intersection(DateObject dateObject, List<DateObject> list) {
        List<DateObject> result = new ArrayList<>();
        for (DateObject date : list) {
            // 时间区间全部在开放时间区间内：ad.startDate <= open.startDate < open.endDate <= ad.endDate
            // 则[open.startDate, open.endDate] 均不开放
            if (date.getStartDate().getTime() <= dateObject.getStartDate().getTime()
                    && date.getEndDate().getTime() >= dateObject.getEndDate().getTime()) {
                // 开放时间区间已全部占用
                break;
            }
            // 时间区间全部在开放时间区间内：open.startDate <= ad.startDate < ad.endDate <= open.endDate
            else if (date.getStartDate().getTime() >= dateObject.getStartDate().getTime()
                    && date.getEndDate().getTime() <= dateObject.getEndDate().getTime()) {
                result.add(new DateObject(date.getStartDate(), date.getEndDate()));
            }
            // 结束时间在开放时间区间内：ad.startDate <= open.startDate <= ad.endDate <= open.endDate
            else if (date.getStartDate().getTime() <= dateObject.getStartDate().getTime()
                    && date.getEndDate().getTime() >= dateObject.getStartDate().getTime()
                    && date.getEndDate().getTime() <= dateObject.getEndDate().getTime()) {
                result.add(new DateObject(dateObject.getStartDate(), date.getEndDate()));
            }
            // 开始时间在开放时间区间内：open.startDate <= ad.startDate <= open.endDate <= ad.endDate
            else if (date.getEndDate().getTime() > dateObject.getEndDate().getTime()) {
                result.add(new DateObject(date.getStartDate(), dateObject.getEndDate()));
            }
        }
        return result;
    }

5. 已知日期区间date再与交集intersection求差集differences

集合intersection中的日期区间已经排好序了，第一个元素的结束日期与下一个元素的开始日期就是要的结果，以此类推

   /**
     * 求差集
     *
     * @param dateObject 日期对象
     * @param list       日期列表
     * @return 差集
     */
    private List<DateObject> differences(DateObject dateObject, List<DateObject> list) {
        List<DateObject> result = new ArrayList<>();
        DateObject first = list.get(0);
        if (list.size() == 1) {
            if (dateObject.getStartDate().getTime() < first.getStartDate().getTime()) {
                result.add(new DateObject(dateObject.getStartDate(), DateUtils.getEndTimeOfDay(DateUtils.plusDays(first.getStartDate(), -1))));
            }
            if (dateObject.getEndDate().getTime() - first.getEndDate().getTime() > 1000) {
                result.add(new DateObject(DateUtils.getFirstTimeOfDay(DateUtils.plusDays(first.getEndDate(), 1)), DateUtils.getEndTimeOfDay(dateObject.getEndDate())));
            }
        } else {
            for (int i = 1; i < list.size(); i++) {
                DateObject next = list.get(i);
                result.add(new DateObject(DateUtils.getFirstTimeOfDay(DateUtils.plusDays(first.getEndDate(), 1)), DateUtils.getEndTimeOfDay(DateUtils.plusDays(next.getStartDate(), -1))));
                first = next;
            }
            DateObject last = list.get(list.size() - 1);
            if (dateObject.getEndDate().getTime() > last.getEndDate().getTime()) {
                result.add(new DateObject(DateUtils.getFirstTimeOfDay(DateUtils.plusDays(last.getEndDate(), 1)), DateUtils.getEndTimeOfDay(dateObject.getEndDate())));
            }
        }
        return result;
    }

6. 测试类

    @Test
    public void test1() throws Exception {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 时间区间
        DateObject open = new DateObject(format.parse("2019-07-01 00:00:00"), format.parse("2019-07-31 23:59:59"));

        // 时间区间列表合并
        List<DateObject> merge = merge(init());
        System.out.println("时间区间求并集：" + JSONObject.toJSONStringWithDateFormat(merge, "yyyy-MM-dd HH:mm:ss"));
        // 求交集
        List<DateObject> intersection = intersection(open, merge);
        System.out.println("时间区间求交集：" + JSONObject.toJSONStringWithDateFormat(intersection, "yyyy-MM-dd HH:mm:ss"));
        // 求差集
        if (intersection.isEmpty()) {
            System.out.println("该区间不可再选：" + JSONObject.toJSONStringWithDateFormat(open, "yyyy-MM-dd HH:mm:ss"));
            return;
        }
        List<DateObject> list = differences(open, intersection);
        System.out.println("时间区间求差集：" + JSONObject.toJSONStringWithDateFormat(list, "yyyy-MM-dd HH:mm:ss"));
    }

测试结果：

时间区间求并集：[{"endDate":"2019-07-10 23:59:59","startDate":"2019-07-01 00:00:00"},{"endDate":"2019-07-20 23:59:59","startDate":"2019-07-15 00:00:00"},{"endDate":"2019-07-25 23:59:59","startDate":"2019-07-22 00:00:00"}]
时间区间求交集：[{"endDate":"2019-07-10 23:59:59","startDate":"2019-07-01 00:00:00"},{"endDate":"2019-07-20 23:59:59","startDate":"2019-07-15 00:00:00"},{"endDate":"2019-07-25 23:59:59","startDate":"2019-07-22 00:00:00"}]
时间区间求差集：[{"endDate":"2019-07-14 23:59:59","startDate":"2019-07-11 00:00:00"},{"endDate":"2019-07-21 23:59:59","startDate":"2019-07-21 00:00:00"},{"endDate":"2019-07-31 23:59:59","startDate":"2019-07-26 00:00:00"}]

7. DateUtils 类

  public class DateUtils {

    /**
     * 获取date当天的最后时间
     *
     * @param date 日期
     * @return date当天的最后时间
     */
    public static Date getEndTimeOfDay(Date date) {
        LocalDateTime localDateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        return Date.from(LocalDateTime.of(localDateTime.toLocalDate(), LocalTime.MAX).atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * 获取date当天的开始日期
     *
     * @param date 日期
     * @return date当天的开始日期
     */
    public static Date getFirstTimeOfDay(Date date) {
        LocalDateTime localDateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        return Date.from(LocalDateTime.of(localDateTime.toLocalDate(), LocalTime.MIN).atZone(ZoneId.systemDefault()).toInstant());
    }
}
hongguo_cheng
关注
  • 4
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
groovy代码-range
07-14
Groovy是一种动态、灵活的编程语言，它与Java高度兼容，并在Java平台上运行。在Groovy中，`range`是一个非常实用的特性，用于表示一个连续的数字序列或字符序列。这个特性使得处理一系列数值或者索引变得简洁而高效...
java8 list find_java8 多个list对象用lambda求差集操作
weixin_31031155的博客
02-25 1454
业务场景：调用同步接口获取当前全部有效账户，数据库已存在部分账户信息，因此需要筛选同步接口中已存在本地的帐户。调用接口获取的数据集合list list = response.getdata().getitems();本地查询出来的账户集合list towlist = accountrepository.findall();筛选差集代码list distinctbyuniquelist = list...
Java中求集合交集、并集、差集
椰汁菠萝
04-21 5256
前言 无论使用哪种方法都要重写equals方法,如果使用Set集合，还需要重写hashCode方法； public class User{ private Integer id; private String name; @Override public boolean equals(Object obj) { if(obj == null) { return false; } if(!(obj instanceof User)) { return false;
java 时间区间类
最新发布
weixin_41182494的博客
07-27 15
函数,构造函数相关学习资料：https://edu.51cto.com/video/2092.htmlhttps://edu.51cto.com/video/2704.htmlJava 时间区间类实现指南 作为一名经验丰富的开发者，我很高兴能够帮助刚入行的小白们理解如何实现一个Java时间区间类。在这篇文章中，我们将一...
Java 计算日期范围内空闲时间/时间区间内取差集
zz7_Sunshine的博客
11-02 2200
业务场景：一个时间区间对多个时间区间去差集，也就是计算出一个时间区间内其他时间区间没有占有的时间段 如下图： 整个时间段为一天的开始至结尾，蓝色为占用的时间段（跨天情况带上日期计算 如2019-10-01 22:00:00-2019-10-02 07:00:00），橙色箭头为需要计算出的时间段 代码实现以一个月为维度，计算当前时间到月底的时间段内所有空闲时段 模拟数据库查询出的List&lt...
java计算时间差_Java中计算两个日期的时间差
weixin_36198673的博客
02-19 2万+
这篇文章将使用两个例子计算两个日期的时间差。1.使用Java SDK。2.使用Joda库。1.使用Java SDK计算两个Date之间的时间差，基本思路为把Date转换为ms(微秒)，然后计算两个微秒时间差。时间的兑换规则如下：1s秒 = 1000ms毫秒 1min分种 = 60s秒 1hours小时 = 60min分钟 1day天 = 24hours小时packagecom.qiyadeng....
java中求两个时间差
fn_2015的博客
02-10 787
if(callLog.getEstablishedtime()!=null && callLog.getTime()!=null){  //establishedtime、time是Date类型 Long connectTime = (callLog.getEstablishedtime().getTime()-callLog.getTime().getTime())/1000;      //
java中如何高效的判断数组中是否包含某个元素---
weixin_30399821的博客
02-22 538
package zaLearnpackage; import org.apache.commons.lang3.ArrayUtils; import java.util.Arrays; import java.util.HashSet; import java.util.Set; //检查数组是否包含某个值的方法 public class TestArray { //使用Lis...
java计算时间差及比较时间大小
yutian88的博客
06-25 350
javaz中对日期时间的处理比较多，代码中列出了3中日期时间计算差值的方法。 比如：现在是2004-03-26 13：31：40 过去是：2004-01-02 11：30：24 我现在要获得两个日期差，差的形式为：XX天XX小时XX分XX秒 java计算时间差及比较时间大小 比如：现在是2004-03-26 13：31：40 过去是：2004-01-02 11：30：...
Redis介绍与内部实现机制PPT
08-10
### Redis介绍与内部实现机制详解 #### 一、Redis特性 **（一）存储结构** Redis，即Remote Dictionary Server的缩写，是一种基于字典结构的高性能键值存储系统。这种设计使得Redis能够高效地处理各种类型的数据...
java 两时间段取差集
qq_38432390的博客
01-26 1029
package com.bjtxjys.utils; import org.junit.Test; import java.math.BigDecimal; import java.text.ParseException; import java.text.SimpleDateFormat; import java.time.LocalTime; import java.time.temporal.ChronoUnit; import java.time.temporal.TemporalUnit; i
Java 计算时间差
热门推荐
sungencheng的博客
02-15 3万+
Java 计算时间差 import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date; public class DateFormatDemo { public static void main(String[] args) { //设置时间格式，为了 能转换成 字符串 DateFormat df = new SimpleDateFormat("yyyy-MM
Java 计算两个日期时间差(天数、时、分、秒、毫秒)
wsl4638886的博客
05-21 1万+
Java 计算两个日期时间差(天数、时、分、秒、毫秒)
Java 获取时间范围差集
鱼阿鱼的博客
02-17 607
Java获取时间的范围差集
JAVA集合取交集或差集操作
WannaRunning的博客
08-27 2万+
记录Set和List两种集合取差集的方法,不需要遍历判断,简单快捷 两个Set集合取差集 使用com.google.common.collect.Sets类的difference方法。 返回两个集合差异的不可修改视图。 返回的集合包含set1包含但set2不包含的所有元素。 set2也可能包含set1不存在的元素； 这些都被忽略了。 返回集合的迭代顺序与set1的迭代顺序匹配。 如果set1和set2是基于不同等价关系的集合（如HashSet 、 TreeSet和IdentityHashMap的 k
时间段差集算法
weixin_35794878的博客
03-15 1077
入参： Timestamp startTime：开始时间 Timestamp endTime：结束时间 List<Pair<Timestamp,Timestamp>> timePairs:：时间段列表，由多个pair组成，一个pair就是一个时间段，pair.key：某个时间段的开始时间，pair.value：某个时间段的结束时间 出参： List<Pair<Timestamp,Timestamp>> pairs：从startTime到endTime的
顺序表实现集合差集 c语言代码
03-30
#include <stdio.h> #define MAXSIZE 100 typedef struct { int data[MAXSIZE]; int length; }SqList; void InitList(SqList *L) { L->length = 0; } int LocateElem(SqList L, int e) { int i; for (i = 0; i < L.length; i++) { if (L.data[i] == e) { return i; } } return -1; } void ListInsert(SqList *L, int i, int e) { if (L->length == MAXSIZE) { printf("List is full.\n"); return; } if (i < 1 || i > L->length + 1) { printf("Insert position is error.\n"); return; } for (int j = L->length - 1; j >= i - 1; j--) { L->data[j + 1] = L->data[j]; } L->data[i - 1] = e; L->length++; } void ListDelete(SqList *L, int i) { if (L->length == 0) { printf("List is empty.\n"); return; } if (i < 1 || i > L->length) { printf("Delete position is error.\n"); return; } for (int j = i; j < L->length; j++) { L->data[j - 1] = L->data[j]; } L->length--; } void PrintList(SqList L) { for (int i = 0; i < L.length; i++) { printf("%d ", L.data[i]); } printf("\n"); } void Difference(SqList *La, SqList Lb) { int i; for (i = 0; i < La->length; i++) { if (LocateElem(Lb, La->data[i]) != -1) { ListDelete(La, i + 1); i--; } } } int main() { SqList La, Lb; InitList(&La); InitList(&Lb); ListInsert(&La, 1, 1); ListInsert(&La, 2, 2); ListInsert(&La, 3, 3); ListInsert(&La, 4, 4); ListInsert(&La, 5, 5); ListInsert(&Lb, 1, 3); ListInsert(&Lb, 2, 4); ListInsert(&Lb, 3, 6); printf("La: "); PrintList(La); printf("Lb: "); PrintList(Lb); Difference(&La, Lb); printf("La - Lb: "); PrintList(La); return 0; }
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值