Java中的equals和hashCode方法详解 java集合——Java中的equals和hashCode方法详解

RectObject对象：
package com.weijia.demo; 
 
public class RectObject { 
  public int x; 
  public int y; 
  public RectObject(int x,int y){ 
    this.x = x; 
    this.y = y; 
  } 
  @Override 
  public int hashCode(){ 
    final int prime = 31; 
    int result = 1; 
    result = prime * result + x; 
    result = prime * result + y; 
    return result; 
  } 
  @Override 
  public boolean equals(Object obj){ 
    if(this == obj) 
      return true; 
    if(obj == null) 
      return false; 
    if(getClass() != obj.getClass()) 
      return false; 
    final RectObject other = (RectObject)obj; 
    if(x != other.x){ 
      return false; 
    } 
    if(y != other.y){ 
      return false; 
    } 
    return true; 
  } 
} 

package com.weijia.demo; 
import java.util.HashSet; 
public class Demo { 
  public static void main(String[] args){ 
    HashSet<RectObject> set = new HashSet<RectObject>(); 
    RectObject r1 = new RectObject(3,3); 
    RectObject r2 = new RectObject(5,5); 
    RectObject r3 = new RectObject(3,3); 
    set.add(r1); 
    set.add(r2); 
    set.add(r3); 
    set.add(r1); 
    System.out.println("size:"+set.size()); 
  } 
} 

/** 
   * Adds the specified element to this set if it is not already present. 
   * More formally, adds the specified element <tt>e</tt> to this set if 
   * this set contains no element <tt>e2</tt> such that 
   * <tt>(e==null ? e2==null : e.equals(e2))</tt>. 
   * If this set already contains the element, the call leaves the set 
   * unchanged and returns <tt>false</tt>. 
   * 
   * @param e element to be added to this set 
   * @return <tt>true</tt> if this set did not already contain the specified 
   * element 
   */ 
  public boolean add(E e) { 
    return map.put(e, PRESENT)==null; 
  } 

/** 
   * Associates the specified value with the specified key in this map. 
   * If the map previously contained a mapping for the key, the old 
   * value is replaced. 
   * 
   * @param key key with which the specified value is to be associated 
   * @param value value to be associated with the specified key 
   * @return the previous value associated with <tt>key</tt>, or 
   *     <tt>null</tt> if there was no mapping for <tt>key</tt>. 
   *     (A <tt>null</tt> return can also indicate that the map 
   *     previously associated <tt>null</tt> with <tt>key</tt>.) 
   */ 
  public V put(K key, V value) { 
    if (key == null) 
      return putForNullKey(value); 
    int hash = hash(key); 
    int i = indexFor(hash, table.length); 
    for (Entry<K,V> e = table[i]; e != null; e = e.next) { 
      Object k; 
      if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { 
        V oldValue = e.value; 
        e.value = value; 
        e.recordAccess(this); 
        return oldValue; 
      } 
    } 
 
    modCount++; 
    addEntry(hash, key, value, i); 
    return null; 
  } 

package com.weijia.demo; 
import java.util.HashSet; 
public class Demo { 
  public static void main(String[] args){ 
    HashSet<RectObject> set = new HashSet<RectObject>(); 
    RectObject r1 = new RectObject(3,3); 
    RectObject r2 = new RectObject(5,5); 
    RectObject r3 = new RectObject(3,3); 
    set.add(r1); 
    set.add(r2); 
    set.add(r3); 
    r3.y = 7; 
    System.out.println("删除前的大小size:"+set.size()); 
    set.remove(r3); 
    System.out.println("删除后的大小size:"+set.size()); 
  } 
} 

/** 
   * Removes the specified element from this set if it is present. 
   * More formally, removes an element <tt>e</tt> such that 
   * <tt>(o==null ? e==null : o.equals(e))</tt>, 
   * if this set contains such an element. Returns <tt>true</tt> if 
   * this set contained the element (or equivalently, if this set 
   * changed as a result of the call). (This set will not contain the 
   * element once the call returns.) 
   * 
   * @param o object to be removed from this set, if present 
   * @return <tt>true</tt> if the set contained the specified element 
   */ 
  public boolean remove(Object o) { 
    return map.remove(o)==PRESENT; 
  } 

/** 
   * Removes the mapping for the specified key from this map if present. 
   * 
   * @param key key whose mapping is to be removed from the map 
   * @return the previous value associated with <tt>key</tt>, or 
   *     <tt>null</tt> if there was no mapping for <tt>key</tt>. 
   *     (A <tt>null</tt> return can also indicate that the map 
   *     previously associated <tt>null</tt> with <tt>key</tt>.) 
   */ 
  public V remove(Object key) { 
    Entry<K,V> e = removeEntryForKey(key); 
    return (e == null ? null : e.value); 
  } 

/** 
   * Removes and returns the entry associated with the specified key 
   * in the HashMap. Returns null if the HashMap contains no mapping 
   * for this key. 
   */ 
  final Entry<K,V> removeEntryForKey(Object key) { 
    int hash = (key == null) ? 0 : hash(key); 
    int i = indexFor(hash, table.length); 
    Entry<K,V> prev = table[i]; 
    Entry<K,V> e = prev; 
 
    while (e != null) { 
      Entry<K,V> next = e.next; 
      Object k; 
      if (e.hash == hash && 
        ((k = e.key) == key || (key != null && key.equals(k)))) { 
        modCount++; 
        size--; 
        if (prev == e) 
          table[i] = next; 
        else 
          prev.next = next; 
        e.recordRemoval(this); 
        return e; 
      } 
      prev = e; 
      e = next; 
    } 
 
    return e; 
  } 

/** 
  * Returns index for hash code h. 
  */ 
  static int indexFor(int h, int length) { 
    return h & (length-1); 
  }