Java 将列表沿元素拆分为子列表_Java_List_Java 8_Collectors

Java 将列表沿元素拆分为子列表

java list java-8

Java 将列表沿元素拆分为子列表,java,list,java-8,collectors,Java,List,Java 8,Collectors,我有这个列表（list）：我想要这样的东西： [["a", "b"], ["c"], ["d", "e"]] String als = Arrays.toString(new String[]{"a", "b", null, "c", null, "d", "e"}); String[] sa = als.substring(1, als.length() - 1).split("null, "); List<List<String>> res = Stream.of

我有这个列表（

list

）：

我想要这样的东西：

[["a", "b"], ["c"], ["d", "e"]]

String als = Arrays.toString(new String[]{"a", "b", null, "c", null, "d", "e"});
String[] sa = als.substring(1, als.length() - 1).split("null, ");
List<List<String>> res = Stream.of(sa).map(s -> Arrays.asList(s.split(", "))).collect(Collectors.toList());

换句话说，我想使用

null

值作为分隔符将列表拆分为子列表，以获得列表列表（

list

）。我正在寻找一个Java8解决方案。我试过使用

收集器。Partitioning by

，但我不确定它是否是我想要的。谢谢

目前我提出的唯一解决方案是实现您自己的定制收集器

在阅读解决方案之前，我想补充一些关于这方面的注意事项。我把这个问题更多地看作是一个编程练习，我不确定它是否可以用并行流来完成

因此，您必须意识到，如果管道以并行方式运行，它将无声地中断
这不是一种理想的行为，应该避免。这就是为什么我在组合器部分抛出一个异常（而不是
（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; } ); }

作为一个例子，这似乎可以并行完成（这要归功于他！）。因此，它将自定义收集器实现简化为：

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;}); }

专用静态收集器splitBySeparator（谓词sep）{ 返回Collector.of（（）->new ArrayList（Arrays.asList（new ArrayList（））），（l，elem）->{if（sep.test（elem））{l.add（newarraylist（））；}else l.get（l.size（）-1）.add（elem）；}，（l1，l2）->{l1.get（l1.size（）-1）.addAll（l2.remove（0））；l1.addAll（l2）；返回l1；}）； }
这让关于并行性的段落有点过时，但是我让它成为一个很好的提醒

请注意，流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; }

private static List splitBySeparator（List List，Predicate这里有另一种方法，它使用分组函数，利用列表索引进行分组在这里，我通过元素后面的第一个索引对元素进行分组，值为null 。因此，在您的示例中，“a” 和“b” 将映射到2 。此外，我还将null 值映射到-1 索引，稍后应该将其删除 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]] 请不要投票。我没有足够的地方在评论中解释这一点这是一个带有流和foreach 的解决方案，但它严格等同于Alexis的解决方案或foreach 循环（不太清晰，我无法摆脱复制构造函数）： List result=new ArrayList（）；最终列表当前=新的ArrayList（）； list.stream（）.forEach（s->{ 如果（s==null）{ 结果.添加（新ArrayList（当前））； current.clear（）； }否则{ 当前。添加； } } ); 结果。添加（当前）；系统输出打印项次（结果）；我知道你想用Java 8找到一个更优雅的解决方案，但我真的认为它并不是为这种情况设计的。正如spoon先生所说，在这种情况下，我们更喜欢天真的方式。解决方案是使用流。collect 。使用其构建器模式创建收集器已经作为解决方案给出了native是另一个重载的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); }); 第一个参数是累积对象第二个函数累积第三个是前面提到的组合器这是一个非常有趣的问题。我提出了一个单线解决方案。它可能性能不太好，但很有效 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(); List List=Arrays.asList（“a”、“b”、null、“c”、null、“d”、“e”）；集合cl=IntStream.range（0，list.size（）） .filter（i->list.get（i）！=null）.boxed（） .collect（收集器.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>> ll = cl.stream().collect(Collectors.toList()); List ll=cl.stream（）.collect（Collectors.toList（））；虽然已经有了几个答案，并且已经有了一个公认的答案，但是这个主题仍然缺少几点。首先，共识似乎是使用流解决这个问题只是一个练习，而传统的for-loop方法更可取。其次，到目前为止给出的答案忽略了一个认可的问题ach使用数组或向量样式的技术，我认为这大大改进了streams解决方案首先，这里是一个常规解决方案，用于讨论和分析： 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; } 获取出现null 的索引非常容易。绊脚石是在左侧添加-1 ，在右侧添加size 。我选择使用Stream.of 进行追加，然后使用flatMapToInt 将它们展平。（我尝试了其他几种方法，但这一种似乎是最干净的。）在这里使用数组作为索引要方便一些。首先，访问数组的符号比列表更好：索引[i] vs.索引。获取（i）。其次，使用数组可以避免装箱此时，数组中的每个索引值（最后一个除外）都比子列表的起始位置小一个。其右边的索引是子列表的结尾。我们只需在数组和映射上进行流式处理 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); }); 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; }); 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(); List<List<String>> ll = cl.stream().collect(Collectors.toList()); 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; } 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()); } // Java plus pidgin Scala int[] indexes = [-1] ++ IntStream.range(0, input.size()) .filter(i -> input.get(i) == null) ++ [input.size()]; 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()); } 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<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(); System.out.println(result); [[a, b], [c], [d, e]] List<String> input = Arrays.asList("a", "b", null, "c", null, "d", "e"); List<List<String>> result = StreamEx.of(input) .groupRuns((a, b) -> a != null && b != null) .remove(list -> list.get(0) == null).toList(); 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) 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()); } 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 = 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); String s = ....; String[] parts = s.split("sth"); List<T> l = ... List<List<T>> parts = l.split(condition) (possibly with several overloaded variants) String als = Arrays.toString(new String[]{"a", "b", null, "c", null, "d", "e"}); String[] sa = als.substring(1, als.length() - 1).split("null, "); List<List<String>> res = Stream.of(sa).map(s -> Arrays.asList(s.split(", "))).collect(Collectors.toList()); List<List<String>> part(List<String> input, List<List<String>> acc, List<String> cur, int i) { if (i == input.size()) return acc; if (input.get(i) != null) { cur.add(input.get(i)); } else if (!cur.isEmpty()) { acc.add(cur); cur = new ArrayList<>(); } return part(input, acc, cur, i + 1); } part(input, new ArrayList<>(), new ArrayList<>(), 0) 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); Arrays.asList(IntStream.range(0, abc.size()-1). filter(index -> abc.get(index).equals("#") ). map(index -> (index)).toArray()). stream().forEach( index -> {for (int i = 0; i < index.length; i++) { if(sublist.size()==0){ sublist.add(new ArrayList<String>(abc.subList(0, index[i]))); }else{ sublist.add(new ArrayList<String>(abc.subList(index[i]-1, index[i]))); } } sublist.add(new ArrayList<String>(abc.subList(index[index.length-1]+1, abc.size()))); });