我有这个列表 (List<String>)：
["a", "b", null, "c", null, "d", "e"]
我希望你能够提供类似这样的内容：
[["a", "b"], ["c"], ["d", "e"]]
换句话说，我想使用null值作为分隔符，将我的列表拆分成子列表，以获取一个列表的列表(List<List<String>>)。 我正在寻找Java 8的解决方案。 我尝试过使用Collectors.partitioningBy，但我不确定它是否符合我的要求。 谢谢！
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] vs. indexes.get(i)。其次，使用数组避免了装箱。 // 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<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日
我与Brian Goetz一起在Devoxx Antwerp 2016上做了一个演讲，题目是“Thinking In Parallel”(video)，其中涉及到了这个问题以及我的解决方案。在那里提出的问题略有不同，是以“#”为分割符而不是空值，但本质相同。在演讲中，我提到我为这个问题编写了大量单元测试。我将它们作为一个独立的程序附在下面，还有我的循环和流实现。读者可以尝试用其他答案提供的解决方案运行这些测试用例，并查看哪些失败了以及原因。(其他解决方案必须根据谓词进行适应，而不是基于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);
}
}
(l1,l2) -> {l1.addAll(l2); return l1;} ），因为当组合两个列表时，它会在并行模式下使用，这样您就会得到异常而不是错误结果。private static Collector<String, List<List<String>>, List<List<String>>> splitBySeparator(Predicate<String> sep) {
final List<String> current = new ArrayList<>();
return Collector.of(() -> new ArrayList<List<String>>(),
(l, elem) -> {
if (sep.test(elem)) {
l.add(new ArrayList<>(current));
current.clear();
}
else {
current.add(elem);
}
},
(l1, l2) -> {
throw new RuntimeException("Should not run this in parallel");
},
l -> {
if (current.size() != 0) {
l.add(current);
return l;
}
);
}
List<List<String>> ll = list.stream().collect(splitBySeparator(Objects::isNull));
输出：
[[a, b], [c], [d, e]]
private static Collector<String, List<List<String>>, List<List<String>>> splitBySeparator(Predicate<String> sep) {
return Collector.of(() -> new ArrayList<List<String>>(Arrays.asList(new ArrayList<>())),
(l, elem) -> {if(sep.test(elem)){l.add(new ArrayList<>());} else l.get(l.size()-1).add(elem);},
(l1, l2) -> {l1.get(l1.size() - 1).addAll(l2.remove(0)); l1.addAll(l2); return l1;});
}
虽然Stream API可以让关于并行性的段落有些过时，但我认为保留它可以作为一个很好的提醒。
请注意，Stream API并不总是一个替代品。有些任务使用流更容易和更适合，而有些任务则不是。在您的情况下，您也可以创建一个实用方法来完成这个任务：
private static <T> List<List<T>> splitBySeparator(List<T> list, Predicate<? super T> predicate) {
final List<List<T>> finalList = new ArrayList<>();
int fromIndex = 0;
int toIndex = 0;
for(T elem : list) {
if(predicate.test(elem)) {
finalList.add(list.subList(fromIndex, toIndex));
fromIndex = toIndex + 1;
}
toIndex++;
}
if(fromIndex != toIndex) {
finalList.add(list.subList(fromIndex, toIndex));
}
return finalList;
}
并且可以像这样调用：List<List<String>> list = splitBySeparator(originalList, Objects::isNull);。
它可以改进以检查边缘情况。
Stream.collect。使用构建器模式创建Collector已经作为解决方案给出。另一种选择是使用另一个重载的collect，这个方法略微有些原始。 List<String> strings = Arrays.asList("a", "b", null, "c", null, "d", "e");
List<List<String>> groups = strings.stream()
.collect(() -> {
List<List<String>> list = new ArrayList<>();
list.add(new ArrayList<>());
return list;
},
(list, s) -> {
if (s == null) {
list.add(new ArrayList<>());
} else {
list.get(list.size() - 1).add(s);
}
},
(list1, list2) -> {
// Simple merging of partial sublists would
// introduce a false level-break at the beginning.
list1.get(list1.size() - 1).addAll(list2.remove(0));
list1.addAll(list2);
});
正如所见，我制作了一个字符串列表的列表，其中至少有一个最后（空）字符串列表。
使用累加器的解决方案：
正如 @StuartMarks 指出的那样，组合器未能充分满足并行处理的契约。
由于 @ArnaudDenoyelle 的评论，这里提供了使用reduce的版本。
List<List<String>> groups = strings.stream()
.reduce(new ArrayList<List<String>>(),
(list, s) -> {
if (list.isEmpty()) {
list.add(new ArrayList<>());
}
if (s == null) {
list.add(new ArrayList<>());
} else {
list.get(list.size() - 1).add(s);
}
return list;
},
(list1, list2) -> {
list1.addAll(list2);
return list1;
});
() -> new ArrayList<List<String>>(Arrays.asList(new ArrayList<>())) 替换供应商部分。 - Alexis C.list.get(list.size() - 1).addAll(list2.remove(0)); 应该改为：list1.get(list1.size() - 1).addAll(list2.remove(0)); - Reut Sharabani请勿投票。我没有足够的空间在评论中解释这个问题。
这是一个使用Stream和foreach的解决方案，但这与Alexis的解决方案或foreach循环严格等效（而且不太清晰，我无法摆脱复制构造函数）：
List<List<String>> result = new ArrayList<>();
final List<String> current = new ArrayList<>();
list.stream().forEach(s -> {
if (s == null) {
result.add(new ArrayList<>(current));
current.clear();
} else {
current.add(s);
}
}
);
result.add(current);
System.out.println(result);
null值处拆分列表。我们可以直观地看到，我们可以使用以下递归策略逐步分解问题：split(L) :
- if (no null value found) -> return just the simple list
- else -> cut L around 'null' naming the resulting sublists L1 and L2
return split(L1) + split(L2)
null值，并在找到一个时立即剪切列表并在子列表上调用递归调用。如果我们没有找到null（基本情况），则我们已完成此分支并只返回列表。连接所有结果将返回我们正在搜索的列表。
null值的列表，或以null结尾或以null开头的列表。public List<List<String>> split(List<String> input) {
OptionalInt index = IntStream.range(0, input.size())
.filter(i -> input.get(i) == null)
.findAny();
if (!index.isPresent())
return asList(input);
List<String> firstHalf = input.subList(0, index.getAsInt());
List<String> secondHalf = input.subList(index.getAsInt()+1, input.size());
return asList(firstHalf, secondHalf).stream()
.map(this::split)
.flatMap(List::stream)
.collect(toList());
}
null值的索引。如果没有找到，则返回该列表。如果找到一个，则将列表分成两个子列表，对它们进行流操作并递归调用split方法。然后提取子问题的结果列表并组合为返回值。parallel()并行化，并且由于问题的函数分解，算法仍然有效。OptionalInt上的orElse方法返回列表的结束索引，使我们能够重新使用第二个流并额外过滤空列表：public List<List<String>> split(List<String> input) {
int index = IntStream.range(0, input.size())
.filter(i -> input.get(i) == null)
.findAny().orElse(input.size());
return asList(input.subList(0, index), input.subList(index+1, input.size())).stream()
.map(this::split)
.flatMap(List::stream)
.filter(list -> !list.isEmpty())
.collect(toList());
}
List<String> list = Arrays.asList("a", "b", null, "c", null, "d", "e");
Function<String, Integer> indexGroupingFunc = (str) -> {
if (str == null) {
return -1;
}
int index = list.indexOf(str) + 1;
while (index < list.size() && list.get(index) != null) {
index++;
}
return index;
};
Map<Integer, List<String>> grouped = list.stream()
.collect(Collectors.groupingBy(indexGroupingFunc));
grouped.remove(-1); // Remove null elements grouped under -1
System.out.println(grouped.values()); // [[a, b], [c], [d, e]]
您还可以通过在 AtomicInteger 中缓存当前最小索引，避免每次获取 null 元素的第一个索引。更新后的 Function 如下：
AtomicInteger currentMinIndex = new AtomicInteger(-1);
Function<String, Integer> indexGroupingFunc = (str) -> {
if (str == null) {
return -1;
}
int index = names.indexOf(str) + 1;
if (currentMinIndex.get() > index) {
return currentMinIndex.get();
} else {
while (index < names.size() && names.get(index) != null) {
index++;
}
currentMinIndex.set(index);
return index;
}
};
经过一些工作，我想到了一个基于流的单行解决方案。最终使用 reduce() 进行分组，这似乎是自然的选择，但将字符串放入 List<List<String>> 中需要一些额外的操作：
List<List<String>> result = list.stream()
.map(Arrays::asList)
.map(x -> new LinkedList<String>(x))
.map(Arrays::asList)
.map(x -> new LinkedList<List<String>>(x))
.reduce( (a, b) -> {
if (b.getFirst().get(0) == null)
a.add(new LinkedList<String>());
else
a.getLast().addAll(b.getFirst());
return a;}).get();
然而，它只有1行！
当使用问题中提供的输入运行时，
System.out.println(result);
产生：
[[a, b], [c], [d, e]]
LinkedList<List<String>>中。我敢打赌这是一个难题。 - Stuart Marks这是一个非常有趣的问题。我想出了一行解决方案。它可能不是很高效，但它有效。
List<String> list = Arrays.asList("a", "b", null, "c", null, "d", "e");
Collection<List<String>> cl = IntStream.range(0, list.size())
.filter(i -> list.get(i) != null).boxed()
.collect(Collectors.groupingBy(
i -> IntStream.range(0, i).filter(j -> list.get(j) == null).count(),
Collectors.mapping(i -> list.get(i), Collectors.toList()))
).values();
这个想法与@Rohit Jain提出的类似。我将空值之间的空间分组。
如果你真的希望得到一个List<List<String>>，你可以添加：
List<List<String>> ll = cl.stream().collect(Collectors.toList());
List<String> list = N.asList(null, null, "a", "b", null, "c", null, null, "d", "e");
Stream.of(list).splitIntoList(null, (e, any) -> e == null, null).filter(e -> e.get(0) != null).forEach(N::println);
AtomicInteger i = new AtomicInteger();
List<List<String>> x = Stream.of("A", "B", null, "C", "D", "E", null, "H", "K")
.collect(Collectors.groupingBy(s -> s == null ? i.incrementAndGet() : i.get()))
.entrySet().stream().map(e -> e.getValue().stream().filter(v -> v != null).collect(Collectors.toList()))
.collect(Collectors.toList());
System.out.println(x);
Collectors.groupingBy与 Python 的itertools.groupby工作方式非常不同，更像是Collectors.partitioningBy，只是有超过两个组，即它会将所有非空字符串放在一个桶中。 - tobias_k