如何根据特定标准将一个流拆分为多个流？

Question

我有一个整数列表，我想使用Java8流返回这个列表中的整数子列表，其中我的子列表在遇到一个负整数之前包含了原始列表中的所有正整数

例如，假设我的列表中有元素

[1 , 2 , 0 , -1 , 5 , 8 , 9 , -11 , 7 , 13 ]

然后我应该返回包含

  [1 , 2 , 0 ] [ 5 , 8 , 9 ] [7 , 13]  

我尝试了以下方法，但它不起作用，你的方向

package Java8;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.stream.Collectors;

public class StreamsExamples {

    public static void main(String[] args) {
        ArrayList<Integer> arr = new ArrayList<Integer>();
        arr.add(1);
        arr.add(2);
        Integer[] al = new Integer[]{0,-1,5,8,9,-11,7,13};
        arr.addAll(Arrays.asList(al));
        arr.stream().collect(Collectors.groupingBy(Functionality::getPositiveList));
        // arr.stream().collect(Collectors.toList()).;
        //arr.stream().sorted().forEach(System.out::print);
    }


}

class Functionality{

    public List<List<Integer>> getPositiveList(List<Integer> list){
        List<List<Integer>> li = new ArrayList<List<Integer>>();
        List<Integer> a = new ArrayList<Integer>();
        for(int i=0;i<list.size();i++) {
            if(list.get(i)>=0) {
                a.add(list.get(i));
            }
            else if (list.get(i)<0) {
                li.add(a);
                a.clear();
            }
        }
        return li;

    }
}

Answer 1

这有点难看，但这是可行的：

List<List<Integer>> lists = Arrays.stream(arr).boxed()
    .reduce(
        new ArrayList<>(),
        (l, i) -> {
            if (l.isEmpty() || i < 0) {
                l.add(new ArrayList<>());
            }
            if (i >= 0) {
                l.get(l.size() - 1).add(i);
            }
            return l;
        }, (a, b) -> {
            a.addAll(b);
            return a;
        });

测试：

int [] arr = {1, 2, 0, -1, 5, 8, 9, -11, 7, 13};

List<List<Integer>> lists = Arrays.stream(arr).boxed().reduce(new ArrayList<>(),
        (l, i) -> {
            if (l.isEmpty() || i < 0) {
                l.add(new ArrayList<>());
            }
            if (i >= 0) {
                l.get(l.size() - 1).add(i);
            }
            return l;
        }, (a, b) -> {
            a.addAll(b);
            return a;
        });

System.out.println(lists);

输出：

[[1, 2, 0], [5, 8, 9], [7, 13]]

Answer 2

如果您认为这里有点不同，那么这并不难：找出负值所在的索引，然后在这些索引之间做一个子列表。。。IntStream有一些怪癖。of（-1）（但我会让您弄明白为什么会是这样：尝试用更直观的IntStream.of（0）替换它，看看发生了什么）。所以有一个输入，比如：

ArrayList<Integer> arr = List.of(1, 2, 0, -1, 5, 8, 9, -11, 7, 13);

首先查找索引：

int[] indexes = IntStream.concat(
IntStream.of(-1),
IntStream.concat(
      IntStream.range(0, arr.size())
               .filter(x -> arr.get(x) < 0),
      IntStream.of(arr.size())))
         .toArray();

System.out.println(Arrays.toString(indexes));

这将产生如下结果：[-1,3,7,10]。

因此，只需计算以下之间的subList：

IntStream.range(0, indexes.length - 1)
         .mapToObj(x -> arr.subList(indexes[x] + 1, indexes[x + 1]))
         .collect(Collectors.toList())
         .forEach(System.out::println);