从列表列表中提取列表[重复]

Posted 2023-02-22

【中文标题】从列表列表中提取列表[重复]

【英文标题】：Extract a list from list of lists [duplicate]

【发布时间】：2017-12-15 16:39:19

【问题描述】：

我在 java 中有一个列表。

static ArrayList<List> permutationS = new ArrayList<List>();

内部列表是整数的 ArrayList。

List<Integer> innerList = new ArrayList<Integer>();

现在我想选择一个innerList，如果它包含一个特定的整数。 我怎样才能做到这一点？

【问题讨论】：

您希望每个列表都至少包含该整数的一个实例吗？

@k.krol.27 将只有一个包含特定整数的列表。下面是一个例子：[[0, 6, 13, 14], [1, 10, 11, 18], [2, 22, 4, 20], [3, -1, 21, 12], [5, 9, 17, 16], [7, 15, 19, 8]]

【参考方案1】：

也许有这样的结构？

for (List<Integer> lists : permutationS) 
    for(Integer integers : lists)
        //Your tests 
    

【参考方案2】：

这将允许您获取包含所需值的列表，如果没有任何内部列表包含它，它将返回一个新的空列表：

int val = 10;
List<Integer> innerList = permutationS.stream()    //iterate over inner lists
        .filter(list -> list.contains(val))        //keep one which contains the value
        .findAny()                                 //keep only one if exists
        .orElse(new ArrayList<>());                // if no-one return new List

---

例子：

permutationS.add(Arrays.asList(0, 6, 13, 14));
permutationS.add(Arrays.asList(1, 10, 11, 18, 6, 78, 79, 9));
permutationS.add(Arrays.asList(2, 22, 4, 20));

List<Integer> innerList = permutationS.stream().filter(list -> list.contains(10))
                                               .findAny().orElse(new ArrayList<>());
innerList.size(); // = 8

List<Integer> innerList2 = permutationS.stream().filter(list -> list.contains(34))
                                                .findAny().orElse(new ArrayList<>());
innnerList2.size(); // = 0

【参考方案3】：

一种解决方案是删除所有不包含特定整数（例如 10）的 List<Integer>s：

permutationS.removeIf(list -> !list.contains(10));

---

另一种解决方案是使用流和过滤来完成它：

permutationS.stream()
            .filter(list -> list.contains(10))
            .collect(Collectors.toList());

---

如果您只寻找一个List<Integer>，那么您可以使用以下内容：

List<Integer> newList = permutationS.parallelStream()
                                    .filter(list -> list.contains(10))
                                    .findAny()
                                    .orElseGet(ArrayList::new);

【讨论】：

parallelStream() 除了在更多内核可用时可以更快地执行之外没有其他优势。 parallelStream() 并不总能保证更快的结果。事实上，与顺序流相比，并行流的开销要高得多。只有在某些情况下您需要使用parallelStream()。

【参考方案4】：

stream的解决方案：

int x = 3; // the number to be looked

List<Integer> selectedInnerList = permutationS.stream()
                                              .filter(s -> s.contains(x))
                                              .findFirst()
                                              .get();

注意findFirst()返回一个Optional对象，所以get()如果没有这个元素会抛出异常

【讨论】：

如果没有列表包含x，这将引发异常

@JacobG。编辑了我的答案以澄清这一点

@AlbertoTrindadeTavares 是从哪里来的？

@sheldoncooper s 是 lambda（匿名函数）的参数。我们不需要显式声明它

【参考方案5】：

这样做：

List<List<Integer>> permutationS = new ArrayList<>();

// list initialization here

int i = 5; // the Integer you are searching for

for(List<Integer> innerList : permutationS) 
   if(innerList.contains(i)) 
     // found, do something with innerList
   

【参考方案6】：

怎么样：

public List getList(Object value) 

    for (List inner : Permutation_S) 
        if (inner.contains(value))
            return inner;
    

【参考方案7】：

目前我不知道您使用的是哪个 Java 版本，我建议像这样循环遍历它

List<List<Integer>> Permutation_S = new ArrayList<List<Integer>>(); 
for(List<Integer> listInList: Permutation_S)
    for(Integer integerValue: listInList)
        if(integerValue == 2 /*your desired value*/)
            //DO SOMETHING
        
    

当然，如果您使用的是 Java 8 或更高版本，您也可以使用流

【讨论】：

permutationS 的类型是 List> 而不是 List>

so List> ?

（实际上更糟糕，因为它使用的是 rawtype 但它被认为与通配符类型相同） Type> 与 Type 因为一切都扩展了 Object，但没有提供 T，所以 T 是不可能的......在哪个 iirc 旁边，它的 E 而不是 T

但他要的是整数