我有包含一些元素的嵌套链表。我想从外部链表中删除重复的内部链表。元素的顺序无关紧要。[Cat,Mouse,Dog] 与 [Mouse,Cat,Dog] 相同，我想要删除其中 1 个。 示例:

假设

[[Cat,Mouse,Dog],[Dog,Mouse,Cat],[Dog,Horse,Cat],[Dog,Tiger,Lion]] 

然后我想要这样的输出

[[Cat,Mouse,Dog],[Dog,Horse,Cat],[Dog,Tiger,Lion]]

我试过了。但我想要最优解…… 我的代码如下

for (int iBoardListCnt = 0; this.roomCombinationsMasterList != null && iBoardListCnt < this.roomCombinationsMasterList.size(); iBoardListCnt++) {

        LinkedList<Board> alRoomCombinationList = new LinkedList<>();
        alRoomCombinationList = this.roomCombinationsMasterList.get(iBoardListCnt);
        ArrayList<String> alTemp = new ArrayList();
        for (int icount = 0; icount < alRoomCombinationList.size(); icount++) {
            alTemp.add((alRoomCombinationList.get(icount).getRoomDescription() + alRoomCombinationList.get(icount).getDescription()).toString());
        }
        roomCombinationsMasterList.remove(iBoardListCnt);



        Collections.sort(alTemp, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.compareToIgnoreCase(s2);
            }
        });

        Iterator<LinkedList<Board>> iterator = roomCombinationsMasterList.iterator();
        while (iterator.hasNext()) {

            ArrayList<String> alTemp1 = new ArrayList<>();
            for (Board data : iterator.next()) {
                alTemp1.add((data.getRoomDescription() + data.getDescription()).toString());

            }
            Collections.sort(alTemp1, new Comparator<String>() {
                @Override
                public int compare(String s1, String s2) {
                    return s1.compareToIgnoreCase(s2);
                }
            });

            if (alTemp.equals(alTemp1)) {
                iterator.remove();
                continue;
            }

        }

        roomCombinationsMasterList.add(iBoardListCnt, alRoomCombinationList);

    }

在这段代码中，我从 Nested LinkedList 中获取了 Fist 元素。存储在临时 LinkedList 中，我从主数组列表中删除了该元素。现在我将 LinkedList 中的下一个元素存储到第二个临时 LinkedList 中。使用 Comparator 对两个 LinkedList 进行排序并使用 equals() 方法比较这两个 LinkedList。如果两者相同，则使用 Iterator 删除其中的一个。 请给我最佳解决方案。

最佳答案

有多种方法可以从列表中删除重复元素。您要达到的“最佳”解决方案将需要使用适当的数据结构，该结构已针对 contains 进行了优化。手术。在你的情况下它将是 HashSet .

想法是在遍历原始集合的同时维护遍历元素的集合并检查当前元素是否已经遍历。此方法会修改您的原始集合。

    List<List<String>> input = new LinkedList<List<String>>(Arrays.asList(
            Arrays.asList("Cat", "Mouse", "Dog"),
            Arrays.asList("Dog", "Mouse", "Cat"),
            Arrays.asList("Dog", "Horse", "Cat"),
            Arrays.asList("Dog", "Tiger", "Lion")));

    Set<Set<String>> distinctElements = new HashSet<Set<String>>();

    for (Iterator<List<String>> iterator = input.iterator(); iterator.hasNext(); ) {
        List<String> element = iterator.next();
        HashSet<String> elementAsSet = new HashSet<String>(element);
        if (!distinctElements.contains(elementAsSet)) {
            distinctElements.add(elementAsSet);
        } else {
            iterator.remove();
        }
    }

    System.out.println(input);

第二个选项是将您的原始列表列表转换为 LinkedHashSet<LinkedHashSet<String>> . LinkedHashSet表现得像 Set和 List同时(实际上，它有这两种数据结构)。因此它消除了重复项，同时保留了元素的顺序，正如您所需要的那样。正如您所说，您必须保留您的 Collection 类型，这可能不是您的选择，但它仍然是一个值得考虑的好(和短)选择。

    LinkedHashSet<LinkedHashSet<String>> results = new LinkedHashSet<LinkedHashSet<String>>();
    for (List<String> strings : input) {
        results.add(new LinkedHashSet<>(strings));
    }
    System.out.println(results);

最后是 Java 8 的一行代码:

LinkedList<LinkedList<String>> results = input.stream().map(LinkedHashSet::new).distinct()
        .map(LinkedList::new).collect(Collectors.toCollection(() -> new LinkedList<LinkedList<String>>()));

或者如果您不关心返回集合的类型，它是更短的版本:

List<List<String>> results = input.stream().map(LinkedHashSet::new).distinct()
        .map(LinkedList::new).collect(Collectors.toList());

关于java - 从 LinkedList 中删除重复项，其中嵌套的集合项可以按任意顺序排列，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31934208/