检查“列表列表”中是否存在特定列表，与顺序无关

Question

我有一个类似的清单

[[0, 5, 10, -1], [1, 8, 3, 4], [2, 9, 6, 7]]

现在我要搜索如果上面的列表列表包含[8,1,4,3]，我只是想忽略元素的顺序。 我该如何实现。 **我尝试过包含，但顺序不同时失败。

编辑：我正在使用的代码

for(List<Integer> innerSList : PermutaionS_toDraw)
        {int elem_trans = 0;

        if(!Final.contains(innerSList))
        {
        Final.add(PermutaionS_toDraw.get(PermutaionS_toDraw.indexOf(innerSList)));
        }
}

Answer 1

遍历所有列表，对于每个列表，检查它们的长度与您要比较的列表的长度相同；如果是，则调用containsAll以检查它是否包含所有值。

for(List<Integer> innerList : permutaionsToDraw){
    int elemTrans = 0;

    if(final.size() != innerList.size() || !final.containsAll(innerSList)) {
        final.add(permutaionsToDraw.get(permutaionsToDraw.indexOf(innerList)));
   }
}

注意

我重命名了您的变量以符合Java命名约定

Answer 2

如您所说，您将要执行一个包含，但是我认为您执行的级别有误。 您不想遍历主列表是否包含您的子列表，而是想遍历主列表并检查其每个值是否包含所有搜索值。 例如，

for (List<String> subList : mainList) {
   if (subList.containsAll(searchList) {
      return true;
   }
}
return false;

这将遍历您的主列表，并检查其每个子级是否包含您要搜索的所有值。 希望这会有所帮助，并且我已经清楚地解释了！

注意：这取决于您使用的集合类型。 标准的String []不适用于此代码

编辑：对您发布的代码做出反应。 我相信您所需要更改的只是将包含转换为包含全部。 包含将只在Final中寻找完全匹配的内容，但是包含所有将比较内容并检查整数中是否完全包含整数集合。 因此，它应该看起来像这样

List<List<Integer>> finalCopy = new LinkedList<>();
for(List<Integer> innerSList : PermutaionS_toDraw){
   for (List<Integer> subList : Final) {
      if(!subList.containsAll(innerSList)) {
         finalCopy.add(innerSList);
      }
   }
}
Final.addAll(finalCopy);

Answer 3

这可以通过在列表接口的任何实现类（在我的示例中为ArrayList）上使用.ContainsAll（）方法来完成。 ContainsAll（）的参数接受一个Collection，ContainsAll（）返回一个布尔值。 请参阅： 列表

如果您已经在使用数组，则可以使用Arrays.asList（）进行转换。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Test {



public static void main(String[] args) {
    List<Integer> integersList = new ArrayList<>();
    integersList.add(1);
    integersList.add(2);
    integersList.add(3);
    integersList.add(4);

    List<Integer> integersList2 = new ArrayList<>();
    integersList2.add(5);
    integersList2.add(6);
    integersList2.add(7);
    integersList2.add(8);

    List<Integer> integersList3 = new ArrayList<>();
    integersList3.add(1);
    integersList3.add(2);
    integersList3.add(3);
    integersList3.add(4);

    List<List> listOfLists = new ArrayList<>();
    listOfLists.add(integersList);
    listOfLists.add(integersList2);
    listOfLists.add(integersList3);

    List<Integer> numbersToLookFor = new ArrayList<>();
    numbersToLookFor.add(1);
    numbersToLookFor.add(2);
    numbersToLookFor.add(3);
    numbersToLookFor.add(4);

    for (List l : listOfLists) {
        if (l.containsAll(numbersToLookFor)) {
            System.out.println(l + "does contain " + numbersToLookFor);
        }
    }

}
}

输出：

[1, 2, 3, 4] does contain [1, 2, 3, 4]
[5, 6, 7, 8] does NOT contain [1, 2, 3, 4]
[1, 2, 3, 4] does contain [1, 2, 3, 4]

---

编辑：如果您要更改数字以寻找不同的顺序，它将仍然返回true。

 //CHANGED from 1 2 3 4 --> 3 1 4 2
    List<Integer> numbersToLookFor = new ArrayList<>();
    numbersToLookFor.add(3);
    numbersToLookFor.add(1);
    numbersToLookFor.add(4);
    numbersToLookFor.add(2);

    for (List l : listOfLists) {
        if (l.containsAll(numbersToLookFor)) {
            System.out.println(l + " does contain " + numbersToLookFor);
        } else
            System.out.println(l + " does NOT contain " + numbersToLookFor);
    }
}

输出：

[1, 2, 3, 4] does contain [3, 1, 4, 2]
[5, 6, 7, 8] does NOT contain [3, 1, 4, 2]
[1, 2, 3, 4] does contain [3, 1, 4, 2]

Answer 4

这应该可以解决问题。 对于每个子列表，此摘要将检查搜索列表的大小是否相同，是否包含相同的元素（以任何顺序排列）以及是否不在列表的最终列表中。

for(List<Integer> innerSList : PermutaionS_toDraw)
        {    
        if(searchlist.size() == innerSList.size() && searchList.containsAll(innerSList)
           && !Final.contains(searchList))
        {
        Final.add(PermutaionS_toDraw.get(PermutaionS_toDraw.indexOf(innerSList)));
        }
}

Answer 5

如果要检查子列表是否包含元素而不考虑顺序，这与检查每个元素的编号是否相同或它们的排序列表是否相等是一回事。 因此，您要做的是要么计算列表中的每个数字并将其添加到HashMap中，要么按排序顺序比较两个列表