尽管已经有几个答案，并且是一个可以接受的答案，但是该主题仍然缺少几点。 首先，共识似乎是使用流解决此问题仅是一种练习，而传统的for循环方法更可取。 其次，到目前为止给出的答案都忽略了使用数组或矢量样式技术的方法，我认为这大大改善了流解决方案。

首先，这是一个常规解决方案，用于讨论和分析：

static List> splitConventional(List input) {

List> result = new ArrayList<>();

int prev = 0;

for (int cur = 0; cur < input.size(); cur++) {

if (input.get(cur) == null) {

result.add(input.subList(prev, cur));

prev = cur + 1;

}

}

result.add(input.subList(prev, input.size()));

return result;

}

这通常很简单，但是有些微妙。 一点是，从prev到prev的待处理子列表始终处于打开状态。 当我们遇到indexes.get(i)时，将其关闭，将其添加到结果列表中，然后前进size。循环之后，我们无条件关闭该子列表。

另一个观察结果是这是一个遍历索引的循环，而不是遍历值本身的循环，因此我们使用算术for循环而不是增强的“ for-each”循环。 但是，这表明我们可以使用索引进行流式处理以生成子范围，而不是通过值进行流式处理并将逻辑放入收集器中(就像乔普·艾肯(Joop Eggen)提出的解决方案一样)。

意识到这一点之后，我们可以看到输入中prev的每个位置都是一个子列表的定界符：它是子列表的右端到左边，而它(加一个)是子列表的左端。 正确的。 如果我们能够处理极端情况，则可以找到一种方法，即找到发生indexes.get(i)元素的索引，将它们映射到子列表，然后收集子列表。

结果代码如下：

static List> splitStream(List input) {

int[] indexes = Stream.of(IntStream.of(-1),

IntStream.range(0, input.size())

.filter(i -> input.get(i) == null),

IntStream.of(input.size()))

.flatMapToInt(s -> s)

.toArray();

return IntStream.range(0, indexes.length-1)

.mapToObj(i -> input.subList(indexes[i]+1, indexes[i+1]))

.collect(toList());

}

获取出现prev的索引非常容易。 绊脚石是在左侧添加indexes.get(i)，在右侧添加size。 我选择使用Stream.of进行附加，然后使用flatMapToInt进行拼合。 (我尝试了其他几种方法，但是这似乎是最干净的。)

在这里使用数组作为索引要方便一些。 首先，与数组相比，访问数组的符号更好：prev与indexes.get(i).其次，使用数组避免装箱。

此时，数组中的每个索引值(最后一个除外)都比子列表的起始位置小一个。 其直接右边的索引是子列表的末尾。 我们只需要在数组上流式传输并将每对索引映射到一个子列表中并收集输出。

讨论

流方法比for循环版本略短，但密度更高。 for循环版本很熟悉，因为我们一直在用Java来做这些事情，但是如果您还不知道该循环应该做什么，那么它就不那么明显了。 在弄清楚prev在做什么以及循环结束后必须关闭open子列表的原因之前，您可能必须模拟一些循环执行。 (我最初忘记了它，但是在测试中发现了这一点。)

我认为，流方法更容易概念化正在发生的事情：获取一个指示子列表之间边界的列表(或数组)。 那是一条轻松的两线客流。 正如我上面提到的，困难在于找到一种将边缘值固定到末端的方法。 如果这样做有更好的语法，例如

// Java plus pidgin Scala

int[] indexes =

[-1] ++ IntStream.range(0, input.size())

.filter(i -> input.get(i) == null) ++ [input.size()];

它将使事情变得更加混乱。 (我们真正需要的是数组或列表理解。)一旦有了索引，将它们映射到实际的子列表并将它们收集到结果列表中就很简单了。

当并行运行时，这当然是安全的。

更新2016-02-06

这是创建子列表索引数组的一种更好的方法。 它基于相同的原理，但是它会调整索引范围并为过滤器添加一些条件，以避免必须串联和平整索引。

static List> splitStream(List input) {

int sz = input.size();

int[] indexes =

IntStream.rangeClosed(-1, sz)

.filter(i -> i == -1 || i == sz || input.get(i) == null)

.toArray();

return IntStream.range(0, indexes.length-1)

.mapToObj(i -> input.subList(indexes[i]+1, indexes[i+1]))

.collect(toList());

}

更新2016-11-23

我在Devoxx Antwerp 2016上与Brian Goetz共同发表了一个主题为“并行思考”(视频)的演讲，其中介绍了此问题和我的解决方案。 出现的问题是有一个细微的变化，该变化在“＃”上分割，而不是null，但在其他方面相同。 在谈话中，我提到我针对此问题进行了大量的单元测试。 我在下面将它们作为一个独立程序附加到了我的循环和流实现中。 对于读者来说，一个有趣的练习是针对我在此处提供的测试用例运行其他答案中提出的解决方案，并查看哪些失败以及为什么失败。 (其他解决方案将不得不根据谓词进行拆分，而不是对null进行拆分。)

import java.util.*;

import java.util.function.*;

import java.util.stream.*;

import static java.util.Arrays.asList;

public class ListSplitting {

static final Map, List>> TESTCASES = new LinkedHashMap<>();

static {

TESTCASES.put(asList(),

asList(asList()));

TESTCASES.put(asList("a", "b", "c"),

asList(asList("a", "b", "c")));

TESTCASES.put(asList("a", "b", "#", "c", "#", "d", "e"),

asList(asList("a", "b"), asList("c"), asList("d", "e")));

TESTCASES.put(asList("#"),

asList(asList(), asList()));

TESTCASES.put(asList("#", "a", "b"),

asList(asList(), asList("a", "b")));

TESTCASES.put(asList("a", "b", "#"),

asList(asList("a", "b"), asList()));

TESTCASES.put(asList("#"),

asList(asList(), asList()));

TESTCASES.put(asList("a", "#", "b"),

asList(asList("a"), asList("b")));

TESTCASES.put(asList("a", "#", "#", "b"),

asList(asList("a"), asList(), asList("b")));

TESTCASES.put(asList("a", "#", "#", "#", "b"),

asList(asList("a"), asList(), asList(), asList("b")));

}

static final Predicate TESTPRED = "#"::equals;

static void testAll(BiFunction, Predicate, List>> f) {

TESTCASES.forEach((input, expected) -> {

List> actual = f.apply(input, TESTPRED);

System.out.println(input + " => " + expected);

if (!expected.equals(actual)) {

System.out.println(" ERROR: actual was " + actual);

}

});

}

static List> splitStream(List input, Predicate super T> pred) {

int[] edges = IntStream.range(-1, input.size()+1)

.filter(i -> i == -1 || i == input.size() ||

pred.test(input.get(i)))

.toArray();

return IntStream.range(0, edges.length-1)

.mapToObj(k -> input.subList(edges[k]+1, edges[k+1]))

.collect(Collectors.toList());

}

static List> splitLoop(List input, Predicate super T> pred) {

List> result = new ArrayList<>();

int start = 0;

for (int cur = 0; cur < input.size(); cur++) {

if (pred.test(input.get(cur))) {

result.add(input.subList(start, cur));

start = cur + 1;

}

}

result.add(input.subList(start, input.size()));

return result;

}

public static void main(String[] args) {

System.out.println("===== Loop =====");

testAll(ListSplitting::splitLoop);

System.out.println("===== Stream =====");

testAll(ListSplitting::splitStream);

}

}