java中的HashSet的add()方法解析

 HashSet的add()方法解析【添加和去重】

示例代码如下：【可用于后续的源码追踪】

public class HomeWork04 {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        // 重复元素的不重复添加
        hashSet.add("hello");
        hashSet.add("world");
        hashSet.add(new String("hello"));
        hashSet.add(new Person("tom",20));
        hashSet.add(new Person("jack",18));
        hashSet.add(new Person("tom",20)); // 重复元素【重写了hashCode和equals之后】

        // 超过阈值，hashSet如何扩容
        for(int i = 0;i<8;i++){
            hashSet.add(i);
        }
        hashSet.add(8);

        // 单链表个数超过8个，单链表树化
        for(int i = 0;i<9;i++){
            hashSet.add(new A(i));
        }


        // 遍历hashSet集合
        Iterator iterator = hashSet.iterator();
        while (iterator.hasNext()) {
            Object obj =  iterator.next();
            System.out.println(obj);
        }

        /**
         *  HashSet的无参构造器:
         *  public HashSet() {
         *      map = new HashMap<>(); // HashSet的底层还是HashMap【k-v】
         *  }
         *  $: 此时HashSet的table是[].
         *
         *  解析add()方法:
         *  1) public boolean add(E e) { ==> 【HashSet】
         *         // 这里的PRESENT是固定的
         *         return map.put(e, PRESENT)==null;
         *     }
         *    $:这里的add()方法，本质就是调用HashMap的put方法，存储key值
         *
         *  2) public V put(K key, V value) { ==> 【HashMap】
         *         return putVal(hash(key), key, value, false, true);
         *     }
         *    $:首先计算key的hash值，通过key的hash值，在table中存放key
         *
         *  3) static final int hash(Object key) { ==> 【HashMap】
         *         int h;
         *         return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
         *     }
         *    $:返回key的hash值
         *
         *  4) final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
         *                    boolean evict) { ==> 【HashMap】
         *         Node<K,V>[] tab; Node<K,V> p; int n, i;
         *         if ((tab = table) == null || (n = tab.length) == 0)
         *             // 首次进入putVal(),table是null,为table扩容
         *             n = (tab = resize()).length;
         *         if ((p = tab[i = (n - 1) & hash]) == null)
         *             // 正式添加元素:
         *             // key求出的hash值经过某种算法，得到table处的索引i
         *             // 以key创建新Node节点,将该节点存放到table[i]处。
         *             tab[i] = newNode(hash, key, value, null);
         *         else {
         *             // table不为空，并且添加的key映射到table数组中的table[i]不为空【冲突】
         *             Node<K,V> e; K k;
         *             // p = table[i],这里p即为相同索引在table的内容
         *             // 比较p.key的hash值和key的hash值，同时比较p.key是否与key相同。
         *             if (p.hash == hash &&
         *                 ((k = p.key) == key || (key != null && key.equals(k))))
         *                 e = p;
         *             // 判断p是否是树节点
         *             else if (p instanceof TreeNode)
         *                 // p是树节点，则用putTreeVal()方式添加key
         *                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
         *             else {
         *             // p仍然是Node类的节点,遍历table[i]处的链表【单链表】
         *                 for (int binCount = 0; ; ++binCount) {
         *                     // 是否到达最后一个节点
         *                     if ((e = p.next) == null) {
         *                         // 最后一个节点，插入key
         *                         p.next = newNode(hash, key, value, null);
         *                         // 链表的个数大于8就要树化
         *                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
         *                             treeifyBin(tab, hash);
         *                         ① break;
         *                     }
         *                     // 遍历过程中，判断当前节点e.hash值是否与key的hash值相同，并且e.key是否与key相同
         *                     if (e.hash == hash &&
         *                         ((k = e.key) == key || (key != null && key.equals(k))))
         *                         ② break;
         *                     // 移动p,通过e = p.next，再次移动e
         *                     // 通过对p.e的交替移动完成遍历。
         *                     p = e;
         *                 }
         *             }
         *
         *             // 将新Node节点的value替换掉旧节点的value【PRESENT不影响】
         *             if (e != null) {
         *                 V oldValue = e.value;
         *                 if (!onlyIfAbsent || oldValue == null)
         *                     e.value = value;
         *                 afterNodeAccess(e);
         *                 return oldValue;
         *             }
         *         }
         *         // 记录不重复添加的个数
         *         ++modCount;
         *         if (++size > threshold)
         *         // 如果当前的个数超过阈值，则需要扩容
         *             resize();
         *         afterNodeInsertion(evict);
         *         return null;
         *     }
         *
         *     $ oldTab:旧table数组,oldCap:旧table的容量,oldThr:旧table的阈值
         *       newCap:新table的容量,newThr:新table的阈值,threshold:最终阈值
         *   5) final Node<K,V>[] resize() { ==> 【HashMap】
         *         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;
         *             }
         *             // 扩容机制：newCap:原数组长度的2倍，newThr:原阈值的2倍。
         *             else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
         *                      oldCap >= DEFAULT_INITIAL_CAPACITY)
         *                 newThr = oldThr << 1;
         *         }
         *         else if (oldThr > 0)
         *             newCap = oldThr;
         *         else {
         *             // 首次oldCap为0,oldThr为0
         *             // 为newCap赋初始值16,为newThr赋初始值0.75 * 16 = 12
         *             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赋最终阈值
         *         threshold = newThr;
         *         // 按照newCap,为table分配存储空间
         *         Node<K, V>[] newTab = (Node<K,V>[])new Node[newCap];
         *         table = newTab;
         *         // oldTab不为空的情况:【复制数据】
         *         if (oldTab != null) {
         *             // 复制旧数组的数据到新数组中
         *             for (int j = 0; j < oldCap; ++j) {
         *                 Node<K,V> e;
         *                 if ((e = oldTab[j]) != null) {
         *                     oldTab[j] = null;
         *                     // 判断j索引的oldTab[j]是否是单个元素
         *                     if (e.next == null)
         *                         // 单个元素的话，计算索引值，存放到newTab中。
         *                         newTab[e.hash & (newCap - 1)] = e;
         *                     else if (e instanceof TreeNode)
         *                         ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
         *                     else {
         *                     // j对应的oldTab[j]是单链表
         *                         // 以下处理方式，尚未理解，仍需多看源码 ???
         *                         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;
         *     }
         */
    }
}
// 使得出现单链表
class A {
    private int num;

    public A(int num) {
        this.num = num;
    }

    @Override
    public int hashCode() {
        return 100;
    }

    @Override
    public String toString() {
        return "A{" +
                "num=" + num +
                '}';
    }
}

/**
 * 自定义对象，重写hashCode()和equals()方法.
 */
class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    /**
     * 1) public static int hash(Object... values) {
     *         return Arrays.hashCode(values);
     *     }
     * 2) public static int hashCode(Object a[]) {
     *         if (a == null)
     *             return 0;
     *
     *         int result = 1;
     *
     *         for (Object element : a)
     *             result = 31 * result + (element == null ? 0 : element.hashCode());
     *
     *         return result;
     *     }
     * @return
     */
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}