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中的完全匹配，但是包含all将比较内容并检查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（）返回一个布尔值。请参阅：List

如果您已经在使用数组，可以使用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中，或者按排序顺序比较两个列表

检查“列表清单”中是否存在特定列表，而不管订单如何

5 个答案: