如何从 Hashmap 中删除重复键

Question

我有一个列表列表。列表中有一个列表。 [[-1, 0, 1], [-1, 2, -1], [0, 1, -1]]，此列表的名称表示结果。结果列表包含重复元素作为列表。 [-1,0,1] 和 [0,1,-1] 它们是相同的。我想制作一个不包含重复项的列表。所以列表结果变为 [[-1,0,1],[-1,2,-1]] 或 [[-1,2,-1],[0,1,-1]] 。

我读到 Hashmap 不能存储重复键但允许重复值。因此，要删除重复项，我正在尝试使用 Hashmap。

但是写完代码后运行良好没有报错。

HashMap<List<Integer>,Integer> final_sol=new HashMap<>();
for(int k1=0;k1<result.size();k1++){
       final_sol.put(result.get(k1),k1);
    }
    System.out.println(final_sol);

输出：

{[-1, 2, -1]=1, [0, 1, -1]=2, [-1, 0, 1]=0}

编写此代码块后，我认为我的重复键不能只显示唯一键。

那我怎样才能使这个列表使用哈希映射唯一呢？Fail to understand

当我使用树形图时，它无法编译并给出一些错误。

Answer 1

Maps确实不保留重复的key，Sets不保留重复的元素，但是你需要明白“duplicate”是根据keys/elementsequals()方法定义的，而基于hash的集合依赖于在其键/元素上具有与equals() 方法一致的hashCode() 方法。

现在你说

[-1,0,1] 和 [0,1,-1] 是一样的。

，但不，就Lists 的平等定义而言，它们不相同。列表元素的顺序很重要，列表需要以反映这一点的方式实现equals()。这就是为什么这两个列表可能作为键出现在同一个 Map 中，并且两者都可能作为元素出现在同一个 Set 中。

那么我怎样才能使用哈希映射使这个列表唯一呢？

显然订单对您的目的而言不重要，因此Lists 并不是真正适合您使用的模型。如果您不需要容纳重复的元素，那么您应该考虑使用 Sets 代替。标准库提供了几种实现，据我了解，其中HashSet 可能最适合您的情况。如果您确实需要容纳重复的元素，那么您正在寻找一个多重集。标准库不提供实现，但第三方提供了一些实现。

当我使用树形图时，它无法编译并给出了一些错误。

是的，它会的，除非您向它提供 Comparator 来确定元素的相对顺序。 TreeMap 将重复项识别为根据其自然顺序或 Comparator 指定顺序比较相等的键。

总体而言，听起来您想要一组集合或一组多重集合，而不是列表列表。我不明白你为什么要将地图带入其中。

Answer 2

试试这样的：

List<List<Integer>> result = Arrays.asList(
      Arrays.asList(-1, 0, 1),
      Arrays.asList(-1, 2, -1),
      Arrays.asList(0, 1, -1)
);
HashMap<Set<Integer>, List<Integer>> final_sol = new HashMap<>();

for (List<Integer> list : result) {
  final_sol.put(new HashSet<>(list), list);
}

System.out.println(final_sol.values());

您认为[-1,0,1] 和[0,1,-1] 它们是相同的，但这不适用于列表，因为元素的顺序很重要。你需要集合来理解equals。

但即便如此，当[0,0,1] 和[0,1,1] 相同时，它也可能不是您所期望的。在这种情况下，您必须将每个列表转换为一个 Map，它会为您提供原始列表中相同 Integer 的计数。

Answer 3

看来您可以通过Set<Set<Integer>> 在线完成此操作。这给了你[[-1, 0, 1], [-1, 2]];与[[-1, 0, 1], [-1, 2, -1]] 同态，但不是您想要的结果。以下是一组三个整数的向量，它们与任何排列比较相等，这与您的示例一致。根据documentation，覆盖equals 需要equivalence relation，并且必然需要hashCode，这样a == b -> hashCode(a) == hashCode(b)。

import java.lang.String;
import java.lang.Integer;
import java.util.Set;
import java.util.LinkedHashSet;

class Java {

    public static void main(String args[]) {
        Set<Three> set = new LinkedHashSet<>();
        set.add(new Three(-1, 0, 1));
        set.add(new Three(-1, 2, -1));
        set.add(new Three(0, 1, -1));
        System.out.printf("%s.\n", set);
    }

}

final class Three {
    private int a, b, c;
    public Three(final int a, final int b, final int c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }
    @Override
    public int hashCode() { return a + b + c; }
    @Override
    public boolean equals(Object o) {
        if(this == o) return true;
        if(!(o instanceof Three)) return false;
        Three t = (Three)o;
        /* Brute force 3! = 6. */
        return a == t.a && b == t.b && c == t.c
            || a == t.a && b == t.c && c == t.b
            || a == t.b && b == t.a && c == t.c
            || a == t.b && b == t.c && c == t.a
            || a == t.c && b == t.a && c == t.b
            || a == t.c && b == t.b && c == t.a;
    }
    @Override
    public String toString() {
        return "["+a+","+b+","+c+"]";
    }
}

这会产生，

[[-1,0,1], [-1,2,-1]].

编辑：以下是上面代码的替换，用于替换一组三个整数的向量，当放入一个集合时，它们比较相等，这也与您的示例一致。

    /** Hashcode is the sum of the unique numbers. */
    @Override
    public int hashCode() {
        int h = a;
        if(a != b) h += b;
        if(c != a && c != b) h += c;
        return h;
    }
    @Override
    public boolean equals(Object o) {
        if(this == o) return true;
        if(!(o instanceof Three)) return false;
        Three t = (Three)o;
        /* t \in this && this \in t. */
        return (a == t.a || a == t.b || a == t.c)
            && (b == t.a || b == t.b || b == t.c)
            && (c == t.a || c == t.b || c == t.c)
            && (t.a == a || t.a == b || t.a == c)
            && (t.b == a || t.b == b || t.b == c)
            && (t.c == a || t.c == b || t.c == c);
    }