我們可以知道Set集合是沒有重復數據的特性，那么對於元素為對象 的情況是否也同樣奏效？可以看一下。舉一個例子：
SetTest.java：
class VO {
private String name;
private String addr;
public VO(String name, String addr) {
this.name = name;
this.addr = addr;
}
@Override
public String toString() {
return "name: " + name + " addr:" + addr;
}
}
@Test
public void testSet() {
Set<VO> vos = new HashSet<>();
VO vo = new VO("wahaha", "sh");
VO vo1 = new VO("wahaha", "bj");
VO vo2 = new VO("wahaha", "sh");
vos.add(vo);
vos.add(vo1);
vos.add(vo2);
for (VO item : vos) {
System.out.println(item.toString());
}
}
結果為：
name: wahaha addr:sh
name: wahaha addr:bj
name: wahaha addr:sh
可見，對於各個字段值都相同的對象，並沒有做去重操作。為什么呢，看一下JDK1.8中HashSet的數據結構：
HashSet.java:
實例化對象：
/**
* Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
* default initial capacity (16) and load factor (0.75).
*/
public HashSet() {
map = new HashMap<>();
}
可見new HashSet()操作實際上是new HashMap<>()，可見底層是以HashMap來實現的。
HashSet.add方法：
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
HashMap.add方法：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
可以從上面的加粗字段看出，判斷插入的key是否存在，要判斷兩點①hash值是否相同；②對應的值是否相同，前者要看hashCode()方法，后者要看equal()方法。下面我們來探索一下基本的數據類型和自定義類類型在計算hashCode和equal的區別，看一下如下代碼：
class VO {
private String name;
private String addr;
public VO(String name, String addr) {
this.name = name;
this.addr = addr;
}
@Override
public String toString() {
return "name: " + name + " addr:" + addr;
}
}
@Test
public void testSet() {
Set<VO> vos = new HashSet<>();
VO vo = new VO("wahaha", "sh");
VO vo1 = new VO("wahaha", "bj");
VO vo2 = new VO("wahaha", "sh");
Integer a = 2;
Integer b = 2;
String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(a.equals(b));
System.out.println(str1.equals(str2));
System.out.println(vo.equals(vo2));
System.out.println(a.hashCode() == b.hashCode());
System.out.println(str1.hashCode() == str2.hashCode());
System.out.println(vo.hashCode() == vo2.hashCode());
vos.add(vo);
vos.add(vo1);
vos.add(vo2);
for (VO item : vos) {
System.out.println(item.toString());
}
}
結果為：
true
true
false
true
true
false
name: wahaha addr:sh
name: wahaha addr:sh
name: wahaha addr:bj
java.lang.Integer.equals()：兩個對象對應的值一致則返回true。
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false;
}
java.lang.String.equals()：兩個字符串對應的值一致則返回true：
public boolean equals(Object anObject) {
if (this == anObject) {//同一個對象，必定是一致的
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {//對比每一個字符
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;//anObject不是String實例，那么返回false
}
java.lang.Object.equals()：兩個對象的引用是否一致，即兩個的對象是否是同一個。
public boolean equals(Object obj) {
return (this == obj);
}
可見對於java.lang.Object.equals()來講，兩個new出來的對象肯定是不一致的，那么在HashMap數據結構中不會被判定成相同的對象（盡管值相同）。下面再看看hashCode的源碼：
java.lang.Integer.hashCode():
@Override
public int hashCode() {
return Integer.hashCode(value);
}
public static int hashCode(int value) {
return value;
}
java.lang.String.hashCode():
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
java.lang.Object.hashCode():
public native int hashCode();
JDK8的默認hashCode的計算方法是通過和當前線程有關的一個隨機數+三個確定值，運用Marsaglia's xorshift schema隨機數算法得到的一個隨機數。
因此，以上可以看到Integer和String也都是根據具體的value值來計算hashCode，那么盡管兩個引用不同但是值相同的對象，依然是想等的，但是Object則不同了。
知道了原因，解決方法就簡單了，那就是重載VO類的equals和hashCode方法，代碼如下：
SetTest.java：
class VO {
private String name;
private String addr;
public VO(String name, String addr) {
this.name = name;
this.addr = addr;
}
@Override
public String toString() {
return "name: " + name + " addr:" + addr;
}
/**
* 如果對象類型是User,先比較hashcode，一致的場合再比較每個屬性的值
*/
@Override
public boolean equals(Object obj) {
if (obj == null)
return false;
if (this == obj)
return true;
if (obj instanceof VO) {
VO vo = (VO) obj;
// 比較每個屬性的值 一致時才返回true
if (vo.name.equals(this.name) && vo.addr.equals(this.addr))
return true;
}
return false;
}
/**
* 重寫hashcode 方法，返回的hashCode不一樣才再去比較每個屬性的值
*/
@Override
public int hashCode() {
return name.hashCode() * addr.hashCode();
}
} // class
@Test
public void testSet() {
Set<VO> vos = new HashSet<>();
VO vo = new VO("wahaha", "sh");
VO vo1 = new VO("wahaha", "bj");
VO vo2 = new VO("wahaha", "sh");
vos.add(vo);
vos.add(vo1);
vos.add(vo2);
for (VO item : vos) {
System.out.println(item.toString());
}
}
結果：
name: wahaha addr:sh
name: wahaha addr:bj
記住集合處理中需要強制遵循如下規則：
1)只要重寫equals，就必須重寫hashCode；
2)因為Set存儲的是不重復的對象，依據hashCode和equals進行判斷，所以Set存儲的對象必須重寫這兩個方法。
3)如果自定義對象做為Map的鍵，那么必須重寫hashCode和equals。
正例：String重寫了hashCode和equals方法，所以我們可以非常愉快的使用String對象作為key來使用。