如何在Java8中将列表列表转换为列表？

如果我有一个

列表

，我如何使用Java 8的功能将其转换为一个

列表

，其中包含相同迭代顺序的所有对象？

您可以使用它将内部列表（转换为流后）展平为单个流，然后将结果收集到一个列表中：

List<List<Object>> list = ...
List<Object> flat = 
    list.stream()
        .flatMap(List::stream)
        .collect(Collectors.toList());

List=。。。
列表平面=
list.stream（）
.flatMap（列表：：流）
.collect（Collectors.toList（））；

您可以从中使用

flatCollect（）

模式

---

注意：我是Eclipse集合的贡献者。

flatmap

更好，但还有其他方法可以实现同样的效果

List<List<Object>> listOfList = ... // fill

List<Object> collect = 
      listOfList.stream()
                .collect(ArrayList::new, List::addAll, List::addAll);

列表列表列表=…//填满
列表收集=
listOfList.stream（）
.collect（ArrayList:：new，List:：addAll，List:：addAll）；

我只想解释另一个场景，如

列表

，此列表包含其他一些文档的列表，如

列表

，

列表

，

列表

。所以结构是

class A {
  List<Documents> documentList;
}

class Documents {
  List<Excel> excels;
  List<Word> words;
  List<PowerPoint> ppt;
}

A类{
清单文件清单；
}
类文档{
列表优秀；
列出单词；
列表ppt；
}

现在，如果您只想从文档中迭代Excel，请执行以下操作

所以代码应该是

 List<Documents> documentList = new A().getDocumentList();

 //check documentList as not null

 Optional<Excel> excelOptional = documentList.stream()
                         .map(doc -> doc.getExcel())
                         .flatMap(List::stream).findFirst();
 if(excelOptional.isPresent()){
   Excel exl = optionalExcel.get();
   // now get the value what you want.
 }

List documentList=newa（）.getDocumentList（）；
//将documentList检查为非空
Optional=documentList.stream（）
.map（doc->doc.getExcel（））
.flatMap（List:：stream）.findFirst（）；
if（可选。isPresent（））{
Excel exl=可选Excel.get（）；
//现在获取您想要的值。
}

---

我希望这可以解决某些人在编码时遇到的问题…

流上的

flatMap

方法肯定可以为您展平这些列表，但它必须为元素创建

Stream

对象，然后为结果创建

Stream

您不需要所有这些

Stream

对象。下面是执行该任务的简单、简洁的代码

// listOfLists is a List<List<Object>>.
List<Object> result = new ArrayList<>();
listOfLists.forEach(result::addAll);

//ListofList是一个列表。
列表结果=新建ArrayList（）；
forEach（结果：：addAll）；

由于

列表

是

Iterable

，因此该代码调用（Java8特性），该特性继承自

Iterable

对

Iterable

的每个元素执行给定操作，直到所有元素都已处理或该操作引发异常。如果指定了迭代顺序，则按迭代顺序执行操作

而

列表

的

迭代器

按顺序返回项目

对于

使用者

，此代码将方法引用（Java 8特性）传递到Java 8之前的方法，以按顺序添加内部列表元素

将指定集合中的所有元素按照指定集合的迭代器返回的顺序追加到此列表的末尾（可选操作）

---

正如@Saravana提到的：

flatmap更好，但还有其他方法可以实现同样的效果

List<List<Object>> listOfList = ... // fill

List<Object> collect = 
      listOfList.stream()
                .collect(ArrayList::new, List::addAll, List::addAll);

listStream.reduce（新的ArrayList（），（l1，l2）->{
l1.addAll（l2）；
返回l1；
});

综上所述，实现这一目标的方法有以下几种：

private <T> List<T> mergeOne(Stream<List<T>> listStream) {
    return listStream.flatMap(List::stream).collect(toList());
}

private <T> List<T> mergeTwo(Stream<List<T>> listStream) {
    List<T> result = new ArrayList<>();
    listStream.forEach(result::addAll);
    return result;
}

private <T> List<T> mergeThree(Stream<List<T>> listStream) {
    return listStream.reduce(new ArrayList<>(), (l1, l2) -> {
        l1.addAll(l2);
        return l1;
    });
}

private <T> List<T> mergeFour(Stream<List<T>> listStream) {
    return listStream.reduce((l1, l2) -> {
        List<T> l = new ArrayList<>(l1);
        l.addAll(l2);
        return l;
    }).orElse(new ArrayList<>());
}

private <T> List<T> mergeFive(Stream<List<T>> listStream) {
    return listStream.collect(ArrayList::new, List::addAll, List::addAll);
}

private List mergeOne（Stream listStream）{
返回listStream.flatMap（List:：stream.collect（toList（））；
}
私有列表mergeTwo（Stream listStream）{
列表结果=新建ArrayList（）；
forEach（结果：：addAll）；
返回结果；
}
私有列表合并三（流列表流）{
返回listStream.reduce（新的ArrayList（），（l1，l2）->{
l1.addAll（l2）；
返回l1；
});
}
私有列表合并四（流列表流）{
返回listStream.reduce（（l1，l2）->{
列表l=新阵列列表（l1）；
l、 addAll（l2）；
返回l；
}).orElse（新ArrayList（））；
}
私有列表合并五（流列表流）{
返回listStream.collect（ArrayList:：new，List:：addAll，List:：addAll）；
}

将

列表

转换为

列表

的方法：

listOfLists.stream().flatMap(List::stream).collect(Collectors.toList());

请参见此示例：

public class Example {

    public static void main(String[] args) {
        List<List<String>> listOfLists = Collections.singletonList(Arrays.asList("a", "b", "v"));
        List<String> list = listOfLists.stream().flatMap(List::stream).collect(Collectors.toList());

        System.out.println("listOfLists => " + listOfLists);
        System.out.println("list => " + list);
    }

}       

在Python中，这可以使用列表理解来完成

list_of_lists = [['Roopa','Roopi','Tabu', 'Soudipta'],[180.0, 1231, 2112, 3112], [130], [158.2], [220.2]]

flatten = [val for sublist in list_of_lists for val in sublist]

print(flatten)

---

我们可以使用flatmap进行此操作，请参考以下代码：

 List<Integer> i1= Arrays.asList(1, 2, 3, 4);
 List<Integer> i2= Arrays.asList(5, 6, 7, 8);

 List<List<Integer>> ii= Arrays.asList(i1, i2);
 System.out.println("List<List<Integer>>"+ii);
 List<Integer> flat=ii.stream().flatMap(l-> l.stream()).collect(Collectors.toList());
 System.out.println("Flattened to List<Integer>"+flat);

List i1=Arrays.asList（1,2,3,4）；
listi2=Arrays.asList（5,6,7,8）；
列表ii=数组.asList（i1，i2）；
系统输出打印项次（“列表”+ii）；
List flat=ii.stream（）.flatMap（l->l.stream（））.collect（collector.toList（））；
System.out.println（“展平到列表”+展平）；

对Eran答案的扩展，这是最重要的答案，如果你有一堆列表层，你可以保持它们的平面映射

如果需要的话，这还提供了一种方便的过滤方法

例如：

List<List<List<List<List<List<Object>>>>>> multiLayeredList = ...

List<Object> objectList = multiLayeredList
    .stream()
    .flatmap(someList1 -> someList1
        .stream()
        .filter(...Optional...))
    .flatmap(someList2 -> someList2
        .stream()
        .filter(...Optional...))
    .flatmap(someList3 -> someList3
        .stream()
        .filter(...Optional...))
    ...
    .collect(Collectors.toList())

List多层列表=。。。
List objectList=多层列表
.stream（）
.flatmap（someList1->someList1
.stream（）
.filter（…可选…）
.flatmap（someList2->someList2
.stream（）
.filter（…可选…）
.flatmap（someList3->someList3
.stream（）
.filter（…可选…）
...
.collect（收集器.toList（））

这在SQL中类似于在SELECT语句中包含SELECT语句。

列表=map.values（）.stream（）.collect（Collectors.toList（））

List employees2=new ArrayList（）；
list.stream（）.forEach(
n->employees2.addAll（n））；

因为，您可以使用

流#mapMulti

List result=listOfLists.stream（）
.mapMulti（（列表，消费者）->{
list.forEach（consumer:：accept）；
})
.collect（Collectors.toList（））；

如果您需要一个不可变的

列表

，您甚至可以使用

toList（）

作为终端操作

List result=listOfLists.stream（）
文科硕士
list_of_lists = [['Roopa','Roopi','Tabu', 'Soudipta'],[180.0, 1231, 2112, 3112], [130], [158.2], [220.2]]

flatten = [val for sublist in list_of_lists for val in sublist]

print(flatten)

['Roopa', 'Roopi', 'Tabu', 'Soudipta', 180.0, 1231, 2112, 3112, 130, 158.2, 220.2]

 List<Integer> i1= Arrays.asList(1, 2, 3, 4);
 List<Integer> i2= Arrays.asList(5, 6, 7, 8);

 List<List<Integer>> ii= Arrays.asList(i1, i2);
 System.out.println("List<List<Integer>>"+ii);
 List<Integer> flat=ii.stream().flatMap(l-> l.stream()).collect(Collectors.toList());
 System.out.println("Flattened to List<Integer>"+flat);

List<List<List<List<List<List<Object>>>>>> multiLayeredList = ...

List<Object> objectList = multiLayeredList
    .stream()
    .flatmap(someList1 -> someList1
        .stream()
        .filter(...Optional...))
    .flatmap(someList2 -> someList2
        .stream()
        .filter(...Optional...))
    .flatmap(someList3 -> someList3
        .stream()
        .filter(...Optional...))
    ...
    .collect(Collectors.toList())

    List<Employee> employees2 = new ArrayList<>();
    
     list.stream().forEach(
             
             n-> employees2.addAll(n));