精华内容
下载资源
问答
  • 给出一个区间集合,请合并所有重叠的区间。 示例 1: 输入: [[1,3],[2,6],[8,10],[15,18]] 输出: [[1,6],[8,10],[15,18]] 解释: 区间[1,3] [2,6] 重叠, 将它们合并为 [1,6]. 示例 2: 输入: [[1,4],[4,5]] ...

    给出一个区间的集合,请合并所有重叠的区间。

    示例 1:

    输入: [[1,3],[2,6],[8,10],[15,18]]
    输出: [[1,6],[8,10],[15,18]]
    解释: 区间[1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

    示例 2:

    输入: [[1,4],[4,5]]
    输出: [[1,5]]
    解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。

    代码如下:

    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    /**
     * 合并区间
     *
     * @Auther: 苏察哈尔丶灿
     * @Date: 2020/8/6 20:04
     * @Slogan: 我自横刀向天笑,笑完我就去睡觉。
     */
    public class Solution02 {
        public static void main(String[] args) {
    //        int[][] arr = {{1, 4}, {5, 4}, {0, 1}};
    //        int[][] arr = {{1, 3}, {6, 2}, {10, 8}, {15, 18}};
    //        int[][] arr = {{1, 4}, {2, 3}};
            int[][] arr = {{2, 3}, {4, 5}, {6, 7}, {8, 9}, {1, 10}};
    //        int[][] arr = {};
    
            int[][] newArr = merge(arr);
            echo(newArr);
        }
    
        public static int[][] merge(int[][] intervals) {
    
            /*
             * 首先,区间就表明 深层数组的0,1两个下表值一定不同,有大有小
             * 先给这两个0,1下标排序,排序为0下标存小值,1下标存大值
             *
             * 然后,按照0下标给所有数组进行排序,让后边数组的0下标一定比前边数组的0下标大
             *
             * 再然后
             * 后边数组的0下标值 < 前边数组的1下标值,合并
             * 后边数组的0下标值 > 前边数组的1下标值,另外起一个区间
             * 因为再往后面的数组的0下标不可能在比之前的1下标小了
             * 原因是因为我们规定过了他是一个按0下标排好序的数组了
             *
             * 开始写代码
             */
    
            if (intervals.length == 0) {
                return new int[0][0];
            }
    
            //先给这两个0,1下标排序
            for (int i = 0; i < intervals.length; i++) {
                if (intervals[i][0] > intervals[i][1]) {
                    // 原地赋值更改变量值
                    intervals[i][0] = intervals[i][0] + intervals[i][1];
                    intervals[i][1] = intervals[i][0] - intervals[i][1];
                    intervals[i][0] = intervals[i][0] - intervals[i][1];
                }
            }
    
            // 然后,按照0下标给所有数组进行排序
            Arrays.sort(intervals, (o1, o2) -> {
                return o1[0] - o2[0];
            });
    
    //        echo(intervals);
    //        System.out.println("=====排序完成=======");
            // 开始对比
            List<int[]> arrayList = new ArrayList<int[]>();
            // 先把初始第一个塞进去
            arrayList.add(new int[]{intervals[0][0], intervals[0][1]});
            for (int i = 1; i < intervals.length; i++) {
                int[] tempArr = arrayList.get(arrayList.size() - 1);
    
                // 后面的小值比前面的大值 还大
                if (tempArr[1] < intervals[i][0]) {
                    // 就得另起一个区间
                    arrayList.add(new int[]{intervals[i][0], intervals[i][1]});
                    continue;
                }
                // 否则 合并区间
                // [1,4][2,3]防止这种坑壁情况
                arrayList.set(arrayList.size() - 1, new int[]{tempArr[0], intervals[i][1] > tempArr[1] ? intervals[i][1] : tempArr[1]});
            }
    
            int[][] returnArr = new int[arrayList.size()][2];
    
            for (int i = 0; i < arrayList.size(); i++) {
    //            System.out.println(arrayList.get(i)[0] + "\t" + arrayList.get(i)[1]);
                returnArr[i][0] = arrayList.get(i)[0];
                returnArr[i][1] = arrayList.get(i)[1];
            }
    
            return returnArr;
        }
    
        // 打印数组
        public static void echo(int[][] arr) {
            for (int i = 0; i < arr.length; i++) {
                System.out.println(Arrays.toString(arr[i]));
            }
        }
    
    }
    
    
    展开全文
  • Java 一个日期区间与一个日期区间集合的差集 代码实现0. 解决思路1. 定义包含[开始日期~结束日期]的对象DateObject2. 初始化DateObject集合对象3. DateObject集合中的日期区间合并4. 已知日期区间`date`与日期区间...

    项目中遇到一个需求,就是过滤出一个日期区间与一个日期区间集合的差集。
    例如:
    已有日期区间:[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. 已知日期区间datelist求交集(找出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());
        }
    }
    
    展开全文
  • 1、准备一个容器数组用来存放合并后的区间集合 2、将所有区间按区间左边界升序排序 3、遍历给定区间数组,比较当前区间右边界下一区间左边界 3.1、将较大值设定为新右边界,并与原左边界构成新区间 3.2、将新区间...

    1、题目描述

    给出一个区间的集合,合并所有重叠的区间。

    2、解题思路

    1、准备一个容器数组用来存放合并后的区间集合
    2、将所有区间按区间左边界升序排序
    3、遍历给定区间数组,比较当前区间右边界和下一区间左边界
    3.1、将较大值设定为新右边界,并与原左边界构成新区间
    3.2、将新区间push()进容器数组
    4、返回容器数组,即为合并后的无重叠区间集合数组

    3、解题代码

    /**
     * @param {number[][]} intervals
     * @return {number[][]}
     */
    var merge = function(intervals) {
        let res = [];
        let len = intervals.length;
        if (len == 0) return [];
        intervals.sort((a, b) => a[0] - b[0]);
        for(let i = 0;i < len;i++){
            let left = intervals[i][0];
            let right = intervals[i][1];
            while (i < len - 1 && right >= intervals[i + 1][0]) {
                i++;
                right = Math.max(right, intervals[i][1]);
            }
            res.push([left, right]);
        }
        return res;
    };
    
    展开全文
  • 给出一个区间集合,请合并所有重叠的区间。 示例 1: 输入: [[1,3],[2,6],[8,10],[15,18]] 输出: [[1,6],[8,10],[15,18]] 解释: 区间 [1,3] [2,6] 重叠, 将它们合并为 [1,6]. 示例2: 输入: [[1,4],[4,5]] ...

    给出一个区间的集合,请合并所有重叠的区间。

    示例 1:

    输入: [[1,3],[2,6],[8,10],[15,18]]
    输出: [[1,6],[8,10],[15,18]]
    解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
    示例 2:

    输入: [[1,4],[4,5]]
    输出: [[1,5]]
    解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。

    来源:力扣(LeetCode)
    链接:https://leetcode-cn.com/problems/merge-intervals
    著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

     

    class Solution {

    public:

        bool isCanMerge(vector<int> &merge1, vector<int> &merge2)

        {

            if (merge1.size() != 2 || merge2.size() != 2)

            {

                return false;

            }

     

            if (merge1[1] < merge2[0])

            {

                return false;

            }

     

            return true;

        }

        

        static bool myfunc(vector<int> &vi, vector<int> &vj)

        {

            return vi[0] < vj[0];

        }

     

        vector<vector<int>> merge(vector<vector<int>>& intervals) {

            if (intervals.size() <= 1)

            {

                return intervals;

            }

     

            std::sort(intervals.begin(), intervals.end(), myfunc);

     

            vector<vector<int>>::iterator itrPre = intervals.begin();

            vector<vector<int>>::iterator itrEnd = intervals.begin();

            itrEnd++;

     

            vector<vector<int>> vect;

            vector<int> temp = *itrPre;

            while (itrEnd != intervals.end())

            {

                if (isCanMerge(temp, *itrEnd))

                {

                    

                    temp[0] = (temp[0] < (*itrEnd)[0]) ? temp[0] : (*itrEnd)[0];

                    temp[1] = (temp[1] > (*itrEnd)[1]) ? temp[1] : (*itrEnd)[1];

                    itrEnd++;

                }

                else

                {

                    vect.push_back(temp);

                    temp.clear();                

                    temp.push_back((*itrEnd)[0]);

                    temp.push_back((*itrEnd)[1]);

                    itrEnd++;

                }            

            }

     

            if (!temp.empty())

            {

                vect.push_back(temp);

            }

     

            return vect;

        }

    };

    展开全文
  • 命题区间集合 常用逻辑用语 函数与导数PPT学习教案.pptx
  • 存在多个时间区间**[开始时间,结束时间]**的集合,求与集合内所有其他元素时间区间都没有交集的元素。 图示如下: 解决方案: 保证所有其他元素的结束时间在该元素的开始时间之前,或者开始时间在该元素的结束时间...
  • 给定一个区间集合,找到需要移除区间的最小数量,使剩余区间互不重叠。 注意: 可以认为区间的终点总是大于它的起点。 区间 [1,2] [2,3] 的边界相互“接触”,但没有相互重叠。 示例 1: 输入: [ [1,2], [2,3], ...
  • 对IPv6相关的通用型与特定型路由算法进行了分析,重点研究了以BSR为基础的IPv6路由算法在查找更新时的不平衡问题,提出了基于前缀区间集合的IPv6路由算法。通过对路由前缀(N)进行范围(K)、集合(M)划分以及...
  • * @Description: 给出一个区间集合,请合并所有重叠的区间。 示例 1: 输入: [[1,3],[2,6],[8,10],[15,18]] 输出: [[1,6],[8,10],[15,18]] 解释: 区间 [1,3] [2,6] 重叠, 将它们合并为 [1,6]. 示例2:..
  • 力扣435:给定一个区间集合,找到需要移除区间的最小数量,使剩余区间互不重叠。 注意: 可以认为区间的终点总是大于它的起点。 区间 [1,2] [2,3] 的边界相互“接触”,但没有相互重叠。 示例 1: 输入: [ [1,2],...
  • 针对区间值模糊集合,给出了2类区间集合套的定义,得到了2个区间值模糊集合的表现定理。
  • 集合与常用逻辑用语是高中数学的基础知识,在高中数学的各个部分有着广泛的应用,函数与导数是高中数学的主干知识,在高考中处于特殊的地位,这部分内容涉及到的高频考点主要有,集合(集合的基本概念、基本关系
  • 区间参数高维多目标优化问题是现实生活中常见的一类优化问题,但其有效的求解方法并不是很多.对此,利用集合的概念,提出一种求解此类问题的新方法.首先,利用衡量解集收敛性、分布性、多样性的3种性能指标将原优化问题...
  • .Skip((pageIndex - 1) * pageSize) .Take(pageSize) 转载于:https://www.cnblogs.com/lijianhong90/p/9741142.html
  • Kotlin进阶之集合区间 集合 与多数语言不一样,Kotlin区分可变与不可变集合(list,sets,maps等等)。精确控制什么时候可以编辑集合有利于减少BUG设计良好的API。 在这之前,理解只读的可变集合与实际不变的...
  • Kotlin集合区间的约定

    千次阅读 2018-02-23 16:00:46
    Kotlin集合区间的约定 1.通过下标来访问元素:getset 在kotlin中我们可以用类似java中数组的方式来访问map中的元素,如:val value=map[key] 也可以用同样的运算符来改变一个可变的元素,如:mutableMap[key]=...
  • 力扣435:给定一个区间集合,找到需要移除区间的最小数量,使剩余区间互不重叠。 注意: 可以认为区间的终点总是大于它的起点。 区间 [1,2] [2,3] 的边界相互“接触”,但没有相互重叠。 示例 1: 输入: [ [1,2],...
  • 区间二型模糊集合的表述与应用
  • 广义区间二型模糊集合的词计算
  • public class num8 { public ArrayList merge(ArrayList intervals){ ArrayList res = new ArrayList(); if(intervals == null || intervals.isEmpty()) return res; Comparator comparator = new Comparator()
  • 区间集合S,含有1000个区间。这些区间可能相交,或相连,或包含等。 所有区间都是闭区间。区间,大小随机,范围随机。 找出S中所有与a相交的区间,只交一个点也算。 可以对S先处理,如排序啊或做一个数据结构什么的...
  • 区间范围和集合运算符 区间范围: between xx and yy:[xx,yy] not between xx and yy: 小于xx 或 大于yy 集合范围: in (值列表) not in(值列表) */ #查询薪资大于等于10000 并且小于等于15000的员工 SELECT * ...
  • =10000,它们是某一个区间的开始值结束值。 【输出】  第一行集合元素的个数,对于每一个区间都至少有一个整数属于该区间,且集合所包含元素数目最少。 【样例输入】 4  3 6  2 4  0 2  4 7 【样例输
  • 以数组 intervals 表示若干个区间集合,其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间,并返回一个不重叠的区间数组,该数组需恰好覆盖输入中的所有区间。力扣56。 福大大 答案2021-09-...
  • 数学闭区间和区间区别是什么

    千次阅读 2016-11-04 09:32:09
    1)满足 a ≤ x ≤ b 的实数 x 的集合, 表示为 [ a,b ],叫做闭区间; 2)满足 a 的实数 x 的集合, 表示为 ( a,b ),叫做开区间; 3)满足 a ≤ x ,a ≤ b 的实数 x 的集合, 分别表示为 [ a,b ),( a,b ],叫做半开...
  • 针对区间概念格Lβα(U,A,R)的概念外延在区间[α,β](0≤α≤β≤1)范围内满足内涵属性的特性,提出基于属性集合幂集的区间概念格Lβα的渐进式生成算法,以提高区间概念格的建格效率。在格结构的生成过程...
  • 大家好,这里是「从零开始学 Kotlin 之『3』集合、数组和区间」,本文首发于公众号「Binguner」,欢迎前往大家关注。 我会每周分享一些关于 Android 其他方向的技术干货或一些关于认知的文章。学习一门技术最好的...
  • 扩充集合Rangespan()span运算返回一个RangeSet中包含所有区间的最小区间,也就是整个RangeSet的最小值与最大值组成的Range区间示例RangeSet rangeSet = TreeRangeSet.create();rangeSet.add(Range.closed(1, 4));...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 115,006
精华内容 46,002
关键字:

区间和集合的区别