谈谈hashCode&equals&HashMap

/** <p>
* As much as is reasonably practical, the hashCode method defined by
* class <tt>Object</tt> does return distinct integers for distinct
* objects. (This is typically implemented by converting the internal
* address of the object into an integer, but this implementation
* technique is not required by the
* Java<font size="-2"><sup>TM</sup></font> programming language.)
*
* @return  a hash code value for this object.
* @see     java.lang.Object#equals(java.lang.Object)
* @see     java.util.Hashtable
*/
public native int hashCode();

/** The <tt>equals</tt> method for class <code>Object</code> implements
* the most discriminating possible equivalence relation on objects;
* that is, for any non-null reference values <code>x</code> and
* <code>y</code>, this method returns <code>true</code> if and only
* if <code>x</code> and <code>y</code> refer to the same object
* (<code>x == y</code> has the value <code>true</code>).
* <p>
* Note that it is generally necessary to override the <tt>hashCode</tt>
* method whenever this method is overridden, so as to maintain the
* general contract for the <tt>hashCode</tt> method, which states
* that equal objects must have equal hash codes.
*
* @param   obj   the reference object with which to compare.
* @return  <code>true</code> if this object is the same as the obj
*          argument; <code>false</code> otherwise.
* @see     #hashCode()
* @see     java.util.Hashtable
*/
public boolean equals(Object obj) {
return (this == obj);
}

Object

x

y

x

y

true

x == y

true

public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = count;
if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
}
return false;
}

/**
* Returns a hash code for this string. The hash code for a
* <code>String</code> object is computed as
* <blockquote><pre>
* s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
* </pre></blockquote>
* using <code>int</code> arithmetic, where <code>s[i]</code> is the
* <i>i</i>th character of the string, <code>n</code> is the length of
* the string, and <code>^</code> indicates exponentiation.
* (The hash value of the empty string is zero.)
*
* @return  a hash code value for this object.
*/
public int hashCode() {
int h = hash;
int len = count;
if (h == 0 && len > 0) {
int off = offset;
char val[] = value;

for (int i = 0; i < len; i++) {
h = 31*h + val[off++];
}
hash = h;
}
return h;
}

s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

package test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

public class Test2 {

public static void main(String[] args) {
Collection<String> list=new ArrayList<String>();
Collection<String> set=new HashSet<String>();

String s1=new String("abc");
String s2=new String("abc");

list.add(s1);
list.add(s2);
set.add(s1);
set.add(s2);

System.out.println(list);
System.out.println(set);
}
}

public boolean add(E e) {
ensureCapacity(size + 1);  // Increments modCount!!
elementData[size++] = e;
return true;
}

public boolean add(E e) {
return map.put(e, PRESENT)==null;
}

public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
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.fei;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

public class HashCodeTest {

public static void main(String[] args) {
Collection<Person> list=new ArrayList<Person>();
Collection<Person> set=new HashSet<Person>();

Person p1=new Person("张三",20);
Person p2=new Person("张三",20);

System.out.println("p1.hashCode="+p1.hashCode());
System.out.println("p2.hashCode="+p2.hashCode());
System.out.println("p1.equals(p2)=="+p1.equals(p2));

list.add(p1);
list.add(p2);
set.add(p1);
set.add(p2);

System.out.println(list.toString()+"   list.size="+list.size());
System.out.println(set.toString()+"  set.size="+set.size());

}

}

package com.fei;

public class Person{
//为了减少代码，属性设问public
public String name;
public int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
@Override
public boolean equals(Object obj){
if(this==obj) return true;
if(obj instanceof Person){
Person anotherPerson=(Person)obj;
if(this.name.equals(anotherPerson.name) && this.age==anotherPerson.age)
return true;
}
return false;
}
@Override
public String toString(){
return "["+name+"  "+age+" ]";
}
}

package com.fei;

public class Person{
//为了减少代码，属性设问public
public String name;
public int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString(){
return "["+name+"  "+age+" ]";
}
}