哈希结构部分集合实现类源码阅读

今天在看文章的时候看到了一道题，结果还挺有意思的，大致内容是：用HashSet存储对象时，若对象的某个属性值发生了变化，利用HashSet的remove方法无法将其删除，于是自己也去试了一下。

代码：定义一个Person2类（之前不知道什么地方用了Person）

debug：

AI给的解释是：

虽然给出了回答，但还是有一点点懵，于是去看了下源码

public boolean add(E e) {
        return map.put(e, PRESENT)==null;
}
  然后ctrl+点击put，直接跳到了HashMap的put方法

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

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

  最后返回的其实就是通过hashCode（）方法生成一个哈希值，跟后面的进行异或操作
（貌似是消除哈希冲突的作用），这个符号>>>表示无符号右移位操作符，在最高位补0，
而>>表示有符号右移位操作符，最高位符号不变

返回接着点putVal函数
代码很长，但有很多if-else，单独看就好点
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的作用是先判断数组是否初始化，如果没有则初始化一个数组，
长度为16，Node<>[] table，长度是16是因为HashMap定义了一个静态变量，
默认初始容量

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 

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

  第二个if就比较好理解了，最开始初始化table数组长度为16，n也等于16，
(n - 1) & hash的意思就是，将哈希值hash（put方法接收你传入的e，
然后hash（e）生成哈希值）映射到0~15区间内，然后映射到的位置
在tab（由table赋值来的）中的位置是否为空，为空则添加到那个位置即可
newNode方法就是创建了一个Node对象

Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
        return new Node<>(hash, key, value, next);
    }

  第二个if后面接了一个else，用来处理映射到的位置上已经有其他元素了，
代码也还是有点多。跟上面一样，一个一个if-else看就好了

    else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
  在第二个if中给p进行了赋值，其实就是那个已经占了位置的元素，
取这个p的哈希值跟之前生成的哈希值比较，如果相同，
且key相同（就是调用add方法传入的那个key），则直接将其替换

            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
  否则看如果p是一个树（红黑树）类型对象，则传进来的key以叶子节点的方式
添加到p后面（p是一个红黑树）

            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;
                }
            }
  如果p不是一个树类型，则传进来的key则以链表的尾插法放在p后面，
但p这个位置可能之前就有其他元素也以尾插法的方式放在了p后面，
所以这里做一个循环判断

 循环中间加入了这个if语句
    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
           treeifyBin(tab, hash);

    static final int TREEIFY_THRESHOLD = 8;

  这个if语句的目的是让链表存储转向红黑树存储，也就是当tab数组某个
位置上的元素个数超过一定的数量之后，就让这些元素以红黑树的形式存储，
不再用链表存储。
  红黑树的存储空间开销大概是链表存储的两倍，但是查找效率是o(log n)级别的，
于是Java底层设置了一个链表与红黑树转换的条件，
链表转红黑树的条件是，比如：p这个元素后面链接的元素超过8个，且tab数组长度超过64则转红黑树


 整个put流程差不多就是这样，还有一些细节再去看看数据结构好一点（其实就是我忘了），比如红黑树等
}

了解完put的实现过程后，就差不多理解了上面的问题，这里结合代码和debug运行结果图更好理解一点

先添加p1，然后修改p1的Name属性，接着删除p1，再添加p3，最后添加新的一个Person2对象，属性值跟一开始的p1一样，debug图为

remove方法的实现和put方法差不多（就像数组的添加和删除），也要计算哈希值

一开始算出的哈希值是根据p1的属性(id：1001，name："AA")，然后根据哈希值映射到创建的HashSet底层创建的table数组上，后面虽然修改了name属性的值，但在table数组中的位置没有变，所以根据修改后的属性值算出的哈希值就变了，删除就失效了。

这里还有一个点，就是HashSet的底层实现用到的是HashMap的方法，HashSet在类内定义了一个HashMap类，调用put时，其实调用的是HashMap的方法，所以看HashSet的源码相当于是看Hash Map？？？

于是又去看了些其他的，比如LinkedHashMap，LinkedHashMap继承HashMap，LinkedHashMap重写了newNode方法

Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
        LinkedHashMap.Entry<K,V> p =
            new LinkedHashMap.Entry<>(hash, key, value, e);
        linkNodeAtEnd(p);
        return p;
    }

定义了一个类，这个类也是继承HashMap的Node类，但是多加了两个属性，before，after，这两个属性是让LinkedHashMap添加元素时又加入了双向链表，记录添加的先后顺序，方便遍历。

LinkedHashMap：
static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after;
        Entry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }

HashMap：
static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

还有LinkedHashSet，继承自HashSet，LinkedHashSet的底层跟LinkedHashMap差不多一样，也会调用LinkedHashMap的方法

算是知道了为什么HashMap是面试高频点😂

今天还顺带看了下ArrayList和LinkedList的源码，不算很难，这里没有展开讲（ArrayList就像是封装了一些常见的数组的操作的类，数组扩容啥的看一看都好理解）

除了看源码，还看了一些视频辅助理解，一脑子扎进源码感觉会稀里糊涂的，因为不知道哪些代码是重点，常常看了后面的，忘记了前面的要干啥了，一步一步来把，其实看完源码后，也就那么一回事。