hashcode与equals必须重写分析

Object对象的hashcode和equals方法

问题：

1. 重写equals，则必须重写hashCode方法，这个结论与==运算符有关系吗？
2. 两个对象比较，Collection、Map、一般的Object子对象对这两个方法覆写是否存在区别？
3. equals相等，则hashcode值必须相同。（这是一个规范；如果违反了该规范，两个对象在使用hashMap、hashSet这些时进行比较，将会得到两个Map对象不相等）

== : 是通过两个对象是否指向同一内存地址来判断的

Object类

---

 # equals方法
 public boolean equals(Object obj) {
        return (this == obj);
 }
 
 # hashcode方法,native方法，由jvm实现。主要是对对象所指向的地址进行hash，获得一个int值
  public native int hashCode();

一般的Object子对象，可只覆写equals方法

---

如果只覆写equals方法，因为在使用时，只是简单的使用A.equals(B)，所以不覆写hashcode方法也可以正常判断两个值是否相等。

List对象可只覆写equals方法

---

1. 如ArrayList，首先查看其equals方法实现：

       # 见AbstractList：判断list中的每个对象是否相等
       public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof List))
            return false;
   
        ListIterator<E> e1 = listIterator();
        ListIterator<?> e2 = ((List<?>) o).listIterator();
        while (e1.hasNext() && e2.hasNext()) {
            E o1 = e1.next();
            Object o2 = e2.next();
            if (!(o1==null ? o2==null : o1.equals(o2)))
                return false;
        }
        return !(e1.hasNext() || e2.hasNext());
    }
   

Map(如HashSet、HashMap）需同时覆写equals和hashcode方法

---

如果只是重写对象的equals，而不重写hashcode方法；将会出现以下问题：首先在put方法时，会出现我们认为是同一个对象的key却出现多次。其次，在调用equals方法是，get方法会出现找不到对应的key值；所以我们误认为相等的两个map却不相等。

   # equals方法
   public boolean equals(Object o) {
      if (o == this)
          return true;

      if (!(o instanceof Map))
          return false;
      Map<?,?> m = (Map<?,?>) o;
      if (m.size() != size())
          return false;

      try {
          Iterator<Entry<K,V>> i = entrySet().iterator();
          while (i.hasNext()) {
              Entry<K,V> e = i.next();
              K key = e.getKey();
              V value = e.getValue();
              if (value == null) {
                  # 最主要的逻辑在于：get方法或者是containsKey方法的实现
                  if (!(m.get(key)==null && m.containsKey(key)))
                      return false;
              } else {
                  if (!value.equals(m.get(key)))
                      return false;
              }
          }
      } catch (ClassCastException unused) {
          return false;
      } catch (NullPointerException unused) {
          return false;
      }

      return true;
  }
  
  # get方法
    public V get(Object key) {
      Node<K,V> e;
       # 在这里获取了key的hash值，里面调用了hashcode方法以及equals方法
      return (e = getNode(hash(key), key)) == null ? null : e.value;
  }
  
  # 另外见put方法,也调用了key的hashcode方法
   public V put(K key, V value) {
      return putVal(hash(key), key, value, false, true);
  }

重写equals方法，一般需要满足下面几条规则：

1. 自反性。对于任何非null的引用值x，x.equals(x)应返回true。可使用：if (this == obj) return true;

2. 对称性。对于任何非null的引用值x与y，当且仅当：y.equals(x)返回true时，x.equals(y)才返回true。 （父类与子类比较）—— instanceof中存在的问题。

3. 传递性。对于任何非null的引用值x、y与z，如果y.equals(x)返回true，y.equals(z)返回true，那么x.equals(z)也应返回true。

4. 一致性。对于任何非null的引用值x与y，假设对象上equals比较中的信息没有被修改，则多次调用x.equals(y)始终返回true或者始终返回false。

对于任何非空引用值x，x.equal(null)应返回false。

关于equals编写规则引用了他人的博客

转载于:https://my.oschina.net/u/3726928/blog/1608440