浅谈HashSet.add方法的实现过程
1.、HashSet与HashMap
HashSet实现了Set接口，它实际上是一个HashMap实例，都是一个存放链表的数组。它不保证存储元素的迭代顺序；此类允许使用null元素。HashSet中不允许有重复元素，这是因为HashSet是基于HashMap实现的。
HashSet中定义的成员变量map是HashMap类型的变量：
private transient HashMap<E,Object> map;
HashSet中的元素都存放在HashMap的key上面，而value中的值都是统一的一个固定对象：
private static final Object PRESENT = new Object();
HashSet的无参构造方法中始化一个空的HashMap对象，用成员变量map存储这个对象的地址：
public HashSet() {
map = new HashMap<>();
}
2、HashSet的add方法与HashMap的put方法
HashSet中add方法调用的是底层HashMap中的put()方法，而如果是在HashMap中调用put，首先会判断key是否存在，如果key存在则修改value值，如果key不存在这插入这个key-value。而在set中没有用到value值，也就不存在修改value值的说法，因此往HashSet中添加元素，首先判断元素（也就是key）是否存在，如果不存在这插入，如果存在着不插入，这样HashSet中就不存在重复值。
3、jdk14中HashSet的add方法底层代码实现
自定义一个测试类，用来调用contains方法，方便后面介绍HashSet的add方法底层代码实现
package day.afe;
import java.util.HashSet;
import java.util.Set;
public class Demo {
public static void main(String[] args) {
Set<String> set = new HashSet<String>();//set存储的是一个上转型对象，因为HashSet是Set接口的一个实现类，出现了父类的引用指向了子类的对象
set.add("Jim");//多态，编译时指向Set中的add方法，运行时会执行HashSet中的add方法
set.add("Jim");
set.add(new String("Jim"));
System.out.println(set.size());//输出结果为1
}
}
HashSet的add方法：
/**
* 如果此set中尚未包含指定元素，则添加指定元素。
* 如果此set已包含该元素，则该调用不更改set并返回false。
* @param e 将添加到此set中的元素。
* @return 如果此set尚未包含指定元素，则返回true。
*/
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
HashSet的add方法底层代码里中用map成员变量调用了HashMap中的put方法，这就说明HashSet的add方法是基于HashMap中的put方法实现的，下面就要看HashMap的put方法底层实现。
4、jdk14中HashMap的put方法底层代码实现
HashMap的put方法：
public V put(K key, V value) {//HashSet的add方法要添加的元素e，传入了HashMap的put方法的key值，而value传入的是一个静态常量PRESENT
return putVal(hash(key), key, value, false, true);
}
put方法又会调用putVal方法，putVal方法传入的第一个参数调用了hash方法，传入的参数是key值，key值是add方法要添加的元素e，所以就应再看一下hash方法。
HashMap的hash方法:
static final int hash(Object key) {//静态方法hash,接收的参数类型是一个Object，key本来是HashMap的put方法的key值，传入hash方法后，key值被向上转型为Object。
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);//如果传入的对象是一个null值，直接返回0；否则会先计算key对象的hashCode()，这里运用了Java多态，如果key值对象重写了HashCode方法，就会调用重写的HashCode()方法，否则就会调用Object中的HashCode()方法，不过传入的key是String类型的，这里会调用String的hashCode方法。之后对得到的hashCode先进行无符号右移运算，再与之前的hashCode进行异或运算，最后计算的值返回。
}
可以看出，在hash方法中，如果一个对象的hashCode()方法计算的值相同，hash()方法计算时的值也一定相同，现在传入的对象是String类型的，那么其hashCode()方法计算的值相同，hash()方法计算时的值也一定相同。
hash方法运行结束后，putVal方法继续执行，接下来该看putVal方法。
HashMap的putVal方法:
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//transient Node<K,V>[] table;table是在HashMap中创建的成员变量，有默认值为null
//table赋值给局部变量tab，并判断其是否为空，是空就将tab存储的数组的长度赋值给n
//若局部变量tab存储的数组不是空数组，数组tab的长度赋值给n，并判断其长度是否为0，长度为0就将tab存储的数组的长度赋值给n
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//HashSet集合内没有想要添加的元素
//如果tab的在（n-1）&hash的值是空，就新建一个节点插入在该位置
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//如果以上条件都不满足，就执行else代码块
else {
Node<K,V> e; K k;
//HashSet集合内含有想要添加的元素
//因为String类中重写了Object中的hashCode方法，若要存入的元素的hashCode与集合已经存在的相同，则他们最后的hash相同
//如果传入hash后tab[i]不为空，调取这个数组每个元素的hash值与想要传入的元素的hash作比较
//逻辑与条件前面的成立，就把这个元素的key地址值赋值给k，再与传入的key地址值作比较
//逻辑或前面的条件不成立，但是传入的key地址值不为空同时传入的key和本数组key元素赋值的k作比较
//因为String类中重写了Object中equals方法，这里实质是比较字符转内容后是否相同
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//成立就将已存在的p值赋值给e
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;
}
}
//如果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);
//未存入某个元素，就直接返回null
return null;
}
HashMap的putVal中需要调用的HashMap里的resize()方法：
//第一次添加元素时，会创建一个长度为16的数组
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;//静态常量，默认容量16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;//为全局变量table赋值
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;//因为全局变量table指向的地址即是newTab，所以table与resize方法返回值指向的是一块相同的空间
}
总结：判断key是否存在就要重写元素所在类的equals()和hashCode()方法，当想要向HashSet中添加元素时，首先会调用此元素所在类hashCode()方法，计算此对象的哈希值，此哈希值决定了此对象在HashSet中存放的位置；若此位置没有被存储对象则直接存储，若已有对象则通过对象所在类的equals()比较两个对象是否相同，相同则不能被添加。
浙公网安备 33010602011771号