2024-9-22 Map

HashMap的put流程知道吗？

第一步，通过hash方法计算key的哈希值。

static final int hash(Object key){

        int h;

        return (key == null)? 0:(h =key.hashCode))^(h>>>16);

}

第二步，数组进行第一次扩容。

if((tab = table) == null || (n = tab.length) == 0)

        n = (tab =resize()).length;

第三步，根据哈希值计算key在数组中的下标，如果对应下标正好没有存放数据，则直接插入。

if((p=tab[i =(n-1)&hash]) == null)

        tab[i] =newNode(hash,key,value,null);

如果对应下标已经有数据了，就需要判断是否为相同的key，是则覆盖value,否则需要判断是否为树节点，是则向树中插入节点，否则向链表中插入数据。

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

        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;

                        }

                }

        }

注意，在链表中插入节点的时候，如果链表长度大于等于8，则需要把链表转换为红黑树。

if (binCount >= TREEIFY_THRESHOLD -1)// -1 for 1st

        treeifyBin(tab,hash);

所有元素处理完后，还需要判断是否超过阈值threshold，超过则扩容。

if(++size>threshould)

        resuze();

只重写equals没重写hashcode,map put的时候会发生什么？

如果只重写equals方法，没有重写hascode方法，那会导致equals相等的两个对象，hashcode不相等，这样的话，这两个对象会被放到不同的桶中，这样就会导致get的时候，找不到对应的值

HashMap怎么查找元素的呢？

HashMap的查找就简单很多：

1.使用扰动函数，获取新的哈希值

2.计算数组下标，获取节点

3.当前节点和key匹配，直接返回 

4.否则，当前节点是否为树节点，查找红黑树

5.否则，遍历链表查找

13.HashMap的hash函数是怎么设计的？

HashMap的哈希函数是先拿到key的hashcode,是一个32位的int类型的数值，然后让hashcode的高16位和低16位进行异或操作

static final int hash(Object key){

        int h;

        //key的hashCode和key的hashCode右移16位做异或运算

        return (key == null) ？0:(h=key.hashCode())^(h>>>16);

}

这么设计是为了降低哈希碰撞的概率·

为什么hash函数能降哈希碰撞？

static final int hash(Object key){ Complexity is 6 it's time to do something...

        int h;

        return (key =null) ? 0 ;(h=key.hashCode())^(h>>>16);

}

在hash函数中，先调用了key的hashCode（）方法，这将会返回一个int类型的哈希值，比如说字符串的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+value;

                }

                hash = h;

        }

        return h;

}

int的范围是-2147483648-2147483647，加起来大概40亿上下的浮动。

只要key的hashCode方法设计的比较合理，一般是很难出现碰撞的。

但问题是，不可能直接搞一个40亿长度的数组啊，那也太铺张浪费了。

我们一般会设置一个较小的数组长度，比如说HashMap的数组初始大小才16,当发现容量不满足的时候再扩容，避免浪费

那当数组长度比较小的时候，我们就需要设计一种比较巧妙的hash算法，来避免发生哈希冲突，尽可能地元素均匀地分布在数组当中。

要达到这个目的，HashMap在两个方面下足了功夫，第一个就是数组的长度必须是2的整数次幂，这样可以保证hash&(n-1）的结果能均匀地分布在数组中。

其作用就相当于hash%n,n为数组的长度，比如说数组长度是16，hash值位20，那么20%16=4，也就是说20这个元素应该放在数组的第4个位置；

hash值为23，那么23%16 =7,也就是说23这个元素应该放在数组的第7个位置

&操作的结果就是哈希值的高位全部归零，只保留n个低位，用来做数组下标访问。

以初始长度16为例，16-1=15。

2进制表示是0000 0000 0000 0000 0000 0000 0000 1111。

和某个哈希值做&运算，结果就是截取了最低的四位。

那问题