详述HashSet中add方法

一、HashSet中对象的创建

在分析HashSet的add方法的底层代码之前我们先要理解HashSet集合中的对象是如何创建的。

先创建一个JavaWeb工程，引入hashset的包，创建含有HashSet类的方法，然后就可以进入HashSet的底层代码：

package hashset;

import java.util.HashSet;

public class Test {

    public static void main(String[] args) {
        HashSet<String>name=new HashSet<>();
    }
}

然后点击进入HashSet的底层代码，其实质是创建了一个HashMap类集合的对象，将它的值赋给了全局变量map：

public HashSet(){
    map=new HashMap<>();
}

二、详述add方法中其他方法

首先来叙述HashSet中add方法的调用，下面是add方法的原代码：

package hashset;

import java.util.HashSet;

public class Test {

    public static void main(String[] args) {
        HashSet<String>set=new HashSet<>();
            set.add("Tom");
    }
}

下面是add方法的底层代码，通过底层代码可以看出add方法的返回值为null，使用了map全局变量（该块内存中存储的是HashMap类集合中的对象）调用HashMap类中的put方法，再次点击put方法，分析put方法的底层代码：

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

下面是put方法的底层代码，put方法中调用了putVal方法，这个方法的第一个参数传递为key的hash方法，下面将会分析hash方法：

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
}

1、(Object key)中的hash方法

这个方法返回值由三位运算符运算出来，当传入的参数key，即最开始传入HashSet集合中的某个变量，等于空的时候则返回值为0，不为空的时候返回一个由按位异或运算符运算出来的数字，这一串表达式中还包含了参数key所调用的hashCode方法，所以hash方法的返回值需要查看hashCode方法的底层代码:

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

在进入hashCode方法之后发现这个方法是由native修饰符修饰的没有方法体的方法，说明这个方法是Java语言native方法调用底层的C语言实现的（就像当下流行的Pathon语言是既可以调用Java语言又可以调用C语言）

public native int hashCode();

首先我们来看一下hashCode方法的作用

package hashset;
 
import java.util.HashSet;
 
public class Test {
 
    public static void main(String[] args) {
        Test test=new Test();
        System.out.println(test);
        System.out.println(test.hashCode());
    }
}

 上述运行结果可以看出hashCode方法中存储的为对象的地址，但是要注意的是调用hashCode方法时对象为String类型的时候找常理来说使用两种方式直接创建和创建新对象创建String类对象得到的字符串的地址是不相同的，我们来看一下两种方式调用hashCode方法输出的结果是否一致。

package hashset;
 
import java.util.HashSet;
 
public class Test {
    public static void main(String[] args) {
        String str1="Tom";
        String str2=new String("Tom");
        System.out.println(str1.hashCode());
        System.out.println(str2.hashCode());
    }
}

 

从运行结果可以看出，输出的结果一致，这是由于在String类中重写了hashCode方法，至于具体的底层代码就不做分析了，只需要记住两个String类型的字符串就算地址不相同，但是只要字符串相同，那么hashCode的返回值就相同。

这时我们再回到hash方法中来，可以得知该三目运算符中其实返回值是一个由参数key的地址决定的一个动态的运算式子，至于其在add方法中具体起什么作用我们后续再分析。

 

分析完hash方法，我们知道了put方法给putVal方法传入的第一个参数的内容了，接下来我们继续往下分析，按住Ctrl键点击putVal方法，得到如下的底层代码：

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;
}

这个底层代码中还存在resize方法，是我们要分析的第二个方法从而得知putVal方法是怎样运行的。

2、resize（）方法
进入resize方法的底层代码，我们目的是分析add方法，所以只需知道resize方法在其中起一个什么即可

import java.util.HashMap.Node;
import java.util.HashMap.TreeNode;

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;
            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;
        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;