虽然已经有几个答案，并且是公认的答案，但这个主题仍然缺少几点。首先，共识似乎是使用流解决这个问题只是一种练习，而传统的 for 循环方法更可取。其次，到目前为止给出的答案都忽略了一种使用数组或矢量样式技术的方法，我认为这种方法可以显着改善流解决方案。
首先，出于讨论和分析的目的，这是一个传统的解决方案：
static List<List<String>> splitConventional(List<String> input) {
List<List<String>> 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 到cur 的待处理子列表始终处于打开状态。当我们遇到null 时，我们将其关闭，将其添加到结果列表中，然后前进prev。循环结束后，我们无条件关闭子列表。
另一个观察是，这是一个索引循环，而不是值本身，因此我们使用算术 for 循环而不是增强的“for-each”循环。但它表明我们可以使用索引流式传输来生成子范围，而不是流式传输值并将逻辑放入收集器（正如 Joop Eggen's proposed solution 所做的那样）。
一旦我们意识到这一点，我们可以看到输入中null 的每个位置都是子列表的分隔符：它是左侧子列表的右端，它（加一）是左侧右侧子列表的末尾。如果我们可以处理边缘情况，那么我们会找到一种方法，即我们找到出现null 元素的索引，将它们映射到子列表，然后收集子列表。
生成的代码如下：
static List<List<String>> splitStream(List<String> 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());
}
获取出现null 的索引非常容易。绊脚石是在左侧添加-1，在右端添加size。我选择使用Stream.of 进行附加，然后使用flatMapToInt 将它们展平。 （我尝试了其他几种方法，但这一种似乎是最干净的。）
这里使用数组作为索引更方便一些。首先，访问数组的符号比列表更好：indexes[i] 与 indexes.get(i)。其次，使用数组可以避免装箱。
此时，数组中的每个索引值（除了最后一个）都比子列表的开始位置小一。紧挨着它的索引是子列表的结尾。我们只需在数组上流式传输并将每对索引映射到一个子列表并收集输出。
讨论
流方法比 for 循环版本略短，但更密集。 for-loop 版本很熟悉，因为我们一直在 Java 中做这些事情，但如果你还不知道这个循环应该做什么，那就不明显了。在弄清楚 prev 正在做什么以及为什么在循环结束后必须关闭打开的子列表之前，您可能需要模拟一些循环执行。 （我最初忘记了它，但我在测试中发现了它。）
我认为，流方法更容易概念化正在发生的事情：获取指示子列表之间边界的列表（或数组）。这是一个简单的流双线。正如我上面提到的，困难在于找到一种将边缘值附加到末端的方法。如果有更好的语法可以做到这一点，例如，
// Java plus pidgin Scala
int[] indexes =
[-1] ++ IntStream.range(0, input.size())
.filter(i -> input.get(i) == null) ++ [input.size()];
这会让事情变得不那么混乱。 （我们真正需要的是数组或列表理解。）一旦有了索引，将它们映射到实际的子列表并将它们收集到结果列表中就很简单了。
当然这在并行运行时是安全的。
2016 年 2 月 6 日更新
这是创建子列表索引数组的更好方法。它基于相同的原则，但它调整了索引范围并为过滤器添加了一些条件，以避免必须连接和平面映射索引。
static List<List<String>> splitStream(List<String> 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 共同发表了一次演讲，题为“并行思考”(video)，其中介绍了这个问题和我的解决方案。出现的问题有一个细微的变化，在“#”而不是 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<String>, List<List<String>>> 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<String> TESTPRED = "#"::equals;
static void testAll(BiFunction<List<String>, Predicate<String>, List<List<String>>> f) {
TESTCASES.forEach((input, expected) -> {
List<List<String>> actual = f.apply(input, TESTPRED);
System.out.println(input + " => " + expected);
if (!expected.equals(actual)) {
System.out.println(" ERROR: actual was " + actual);
}
});
}
static <T> List<List<T>> splitStream(List<T> 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 <T> List<List<T>> splitLoop(List<T> input, Predicate<? super T> pred) {
List<List<T>> 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);
}
}