Java覆盖两个可互换整数的equals（）和hashcode（）

Question

我正在覆盖两个int的简单容器对象的equals和hashcode方法。每个int反映另一个对象的索引（该对象是什么并不重要）。该类的目的是表示两个对象之间的连接。

连接的方向无关紧要，因此equals方法应该返回true，无论两个整数在对象中以何种方式循环。

connectionA = new Connection(1,2);
connectionB = new Connection(1,3);
connectionC = new Connection(2,1);

connectionA.equals(connectionB); // returns false
connectionA.equals(connectionC); // returns true

这是我所拥有的（从整数的源代码修改）：

public class Connection {
    // Simple container for two numbers which are connected.
    // Two Connection objects are equal regardless of the order of from and to.

    int from;
    int to;

    public Connection(int from, int to) {
        this.from = from;
        this.to = to;
    }

    // Modifed from Integer source code
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Connection) {
            Connection connectionObj = (Connection) obj;
            return ((from == connectionObj.from && to == connectionObj.to) || (from == connectionObj.to && to == connectionObj.from));
        }
        return false;
    }

    @Override
    public int hashCode() {
        return from*to;
    }
}

但我的问题是：有没有更好的方法来实现这一点？

我主要担心的是hashcode（）方法会为任何两个相乘等于相同数字的整数返回相同的hashcode。例如。

3*4 = 12
2*6 = 12 // same!

文件，http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Object.html#hashCode（）表示

如果根据equals（java.lang.Object）方法，两个对象是不等的，那么对这两个对象中的每一个调用hashCode方法都必须产生不同的整数结果，这不是必需的。然而，程序员应该知道，为不相等的对象生成不同的整数结果可能会提高哈希表的性能。

如果有人能找到一种简单的方法来减少匹配哈希码的数量，那么我将非常感谢你的回答。

谢啦！

提姆

附言：我知道有一个java.sql.连接可能会导致一些导入问题。该对象在我的应用程序中实际上有一个更具体的名称，但为了简洁起见，我在这里将其缩短为连接。

Answer 1

我觉得

@Override
public int hashCode() {
    return to*to+from*from;
}

这就足够了

Answer 2

这是被广泛接受的方法：

@Override
public int hashCode() {
    int res = 17;
    res = res * 31 + Math.min(from, to);
    res = res * 31 + Math.max(from, to);
    return res;
}

Answer 3

已经提出了三种“可行”的解决方案。（所谓工作，我的意思是它们满足哈希代码的基本要求……不同的输入产生不同的输出……而且它们还满足OP的额外“对称”要求。）

这些是：

   # 1
   return from ^ to;

   # 2
   return to*to+from*from;

   # 3
   int res = 17;
   res = res * 31 + Math.min(from, to);
   res = res * 31 + Math.max(from, to);
   return res;

第一个问题是，输出范围受到实际输入值范围的限制。例如，如果我们假设输入都是非负数，分别小于或等于2ⁱ和2^j，那么输出将小于或等于2^{max（i，j）}。这很可能会导致哈希表中的“分散度”很差。。。以及更高的碰撞率。（当from==to时也有问题！）

第二个和第三个要比第一个好，但是如果from和to较小，你仍然可能会遇到更多的碰撞。

如果将从和到的较小值的冲突降至最低是至关重要的，我建议使用第四种选择。

  #4
  int res = Math.max(from, to);
  res = (res << 16) | (res >>> 16);  // exchange top and bottom 16 bits.
  res = res ^ Math.min(from, to);
  return res;

这样做的好处是，如果from和to都在0...2¹⁶-1范围内，您将为每个不同的（无序）对获得唯一的哈希码。

1-我不知道这是否是正确的技术术语...