尽管已经有几个答案，并且是一个可以接受的答案，但是该主题仍然缺少几点。首先，共识似乎是使用流解决此问题仅是一种练习，而传统的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）提出的解决方案一样）。
意识到这一点之后，我们可以看到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]vs.indexes.get(i)。其次，使用数组可避免装箱。
此时，数组中的每个索引值（最后一个除外）都比子列表的起始位置小一个。其直接右边的索引是子列表的末尾。我们只需在数组上流式传输并将每对索引映射到一个子列表中并收集输出。
讨论区
流方法比for循环版本略短，但密度更高。for循环版本很熟悉，因为我们一直在用Java来做这些事情，但是如果您还不知道该循环应该做什么，那么它就不那么明显了。在弄清楚prev正在做什么以及为什么在循环结束后必须关闭打开子列表之前，可能必须模拟一些循环执行。（我最初忘记了它，但是在测试中发现了这一点。）
我认为，流方法更容易概念化正在发生的事情：获取一个指示子列表之间边界的列表（或数组）。那是一条轻松的两线客流。正如我上面提到的，困难在于找到一种将边缘值固定到两端的方法。如果这样做有更好的语法，例如，
int[] indexes =
[-1] ++ IntStream.range(0, input.size())
.filter(i -> input.get(i) == null) ++ [input.size()];
它将使事情变得更加混乱。（我们真正需要的是数组或列表理解。）一旦有了索引，将它们映射到实际的子列表中并将它们收集到结果列表中就很简单了。
当并行运行时，这当然是安全的。
更新2016-02-06
这是创建子列表索引数组的一种更好的方法。它基于相同的原理，但是它会调整索引范围并为过滤器添加一些条件，以避免必须串联和平整索引。
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共同提出了一个主题为“并行思考”的视频（视频），其中介绍了此问题和我的解决方案。出现的问题是有一个细微的变化，它以“＃”代替了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);
}
}
[list(v) for k, v in groupby(lst, key=lambda x: x is not None) if k]。有Collectors.groupingBy，但是老实说我不明白它是如何工作的……