Java中的区间和

我在代码战中被这个卡塔卡住了，我已经尝试了很长时间，比如一个星期左右的卡塔。如果你想了解我的问题，那就去吧

这是我的代码，如果你相信我，里面有很多bug。有人能帮我吗

public static int sumIntervals(int[][] intervals) {
    int sum = 0;
    int[] currentLargeInterval = {intervals[0][0], intervals[0][0]};
    ArrayList<int[]> addedIntervals = new ArrayList<>();
    ArrayList<int[]> arrays = new ArrayList<>();
    addAll(arrays, intervals);
    ArrayList<int[]> removed = new ArrayList<>();
    for (int i = 0; i < arrays.size(); i++) {
        if (i > 0) {
            if (arrays.get(i - 1)[1] >= arrays.get(i)[0] && arrays.get(i - 1)[1] < arrays.get(i)[1]) {
                removed.add(arrays.get(i));
                currentLargeInterval[1] = arrays.get(i)[1];
            } else {
                addedIntervals.add(currentLargeInterval);
                currentLargeInterval = new int[]{arrays.get(i - 1)[0], arrays.get(i - 1)[0]};
            }
        }
    }
    addedIntervals.add(currentLargeInterval);
    arrays.removeAll(removed);
    arrays.addAll(addedIntervals);
    for (int[] a : arrays) {
        System.out.println(Arrays.toString(a));
    }
    return sum;
}

公共静态int-sumpinterval（int[][]间隔）{
整数和=0；
int[]currentLargeInterval={Interval[0][0]，Interval[0][0]}；
ArrayList addedIntervals=新的ArrayList（）；
ArrayList数组=新的ArrayList（）；
addAll（数组、间隔）；
ArrayList removed=新的ArrayList（）；
对于（int i=0；i0）{
if（arrays.get（i-1）[1]>=arrays.get（i）[0]&&arrays.get（i-1）[1]

我认为解决方案总体上过于复杂（这使得bug更难发现），似乎真正需要做的是不要在

集合中添加重复项，然后输出集合的大小

我快速制作了一个版本（我只在其中两个测试中进行了测试）

publicstaticvoidmain（字符串[]args）{
int[][]区间={{1,5}，{10,20}，{1,6}，{16,19}，{5,11}；
系统输出println（sumpinterval（interval））；
}
公共静态整数间隔（整数[][]间隔）{
ArrayList值=新的ArrayList（）；
对于（int[]行：间隔）{
for（int k=行[0]；k<行[1]；k++）{
如果（！values.contains（k））{
增加（k）；
}
}
}
返回值。size（）；
}

输出：

十九,

此解决方案首先对外部数组进行迭代以获得每个范围，然后使用这些值在它们之间进行迭代，如果数字不在
列表中，则使用
.contains（）
将每个数字添加到
列表中

最后，它返回包含每个非重复数字的
列表的
大小
。
我认为总体上解决方案过于复杂（这使bug更难发现），似乎真正需要的是不要在
集合中添加重复项，然后输出集合的大小

我快速制作了一个版本（我只在其中两个测试中进行了测试）

publicstaticvoidmain（字符串[]args）{
int[][]区间={{1,5}，{10,20}，{1,6}，{16,19}，{5,11}；
系统输出println（sumpinterval（interval））；
}
公共静态整数间隔（整数[][]间隔）{
ArrayList值=新的ArrayList（）；
对于（int[]行：间隔）{
for（int k=行[0]；k<行[1]；k++）{
如果（！values.contains（k））{
增加（k）；
}
}
}
返回值。size（）；
}

输出：

十九,

此解决方案首先对外部数组进行迭代以获得每个范围，然后使用这些值在它们之间进行迭代，如果数字不在
列表中，则使用
.contains（）
将每个数字添加到
列表中

最后，它返回包含每个非重复数字的
列表的
大小。
我使用
位集提出了一个稍微不同的解决方案。原理很简单。设置测试套件中指定范围描述的位范围。
重叠通过以下事实来处理：某些位将在已建立的范围内设置多次。基数是设置的位数，也是范围的总和


位集b=新位集（）；
对于（int[]arr:list）{
b、 集合（arr[0]，arr[1]）；
}
sum=b.基数（）；
系统输出打印项数（总和）；
我使用
位集提出了一个稍微不同的解决方案。原理很简单。设置测试套件中指定范围描述的位范围。
重叠通过以下事实来处理：某些位将在已建立的范围内设置多次。基数是设置的位数，也是范围的总和


位集b=新位集（）；
对于（int[]arr:list）{
b、 集合（arr[0]，arr[1]）；
}
sum=b.基数（）；
系统输出打印项数（总和）；
我用
Intstream
得到了这个超级快速的答案

 public static int sumIntervals(int[][] intervals) {
        return intervals == null ? 0 : (int) Arrays.stream(intervals)
            .flatMapToInt(interval -> IntStream.range(interval[0], interval[1]))
            .distinct()
            .count();
    }

我用
Intstream
得到了这个超级快速的答案

 public static int sumIntervals(int[][] intervals) {
        return intervals == null ? 0 : (int) Arrays.stream(intervals)
            .flatMapToInt(interval -> IntStream.range(interval[0], interval[1]))
            .distinct()
            .count();
    }

实际上，@Nexevis提供的代码可以工作，但只需使用集合而不是ArrayList就可以更快

    public static int sumIntervals(int [][] intervals) {
       if(intervals == null || intervals.length == 0) {
         return 0 ; 
       }
       Set<Integer> numsSet = new HashSet<>() ; 
       for (int [] row : intervals) {
           for (int k = row[0]; k < row[1]; k++) {
               if (!numsSet.contains(k)) {
                   numsSet.add(k);
               }
           }
       }
    return numsSet.size();
   }

公共静态int-sumpinterval（int[][]间隔）{
if（interval==null | | interval.length==0）{
返回0；
}
Set numset=new HashSet（）；
对于（int[]行：间隔）{
for（int k=行[0]；k<行[1]；k++）{
如果（！numset.contains（k））{
numset.add（k）；
}
}
}
返回numset.size（）；
}

由于使用集合通常比使用数组或ArrayList更快，我认为这将使您的代码更快

我知道这是一个古老的答案，你可能已经自己找到了，但很高兴能在这里让大家看看是否有其他人遇到了同样的问题。
事实上，@Nexevis提供的代码将有效