hashmap原理_小白定能看懂的HashMap实现原理

最新推荐文章于 2021-10-11 14:42:45 发布

weixin_39743423

最新推荐文章于 2021-10-11 14:42:45 发布

阅读量71

点赞数

文章标签： hashmap原理 hashmap实现原理 hashmap底层实现原理 hashmap的实现原理

1 散列查找

先来回顾一下数据结构查找知识点—散列（哈希）查找

查找定义：给定某个目标值，在数据集中确定一个其关键字等于目标值的数据元素的位置
散列查找：关键字与在数据集中的位置一一对应，通过此对应关系能快速地找到目标值所在的位置。散列查找前提是要构造哈希表，构造哈希表主要包含两部分：散列函数的构造和处理冲突的方法。

什么是哈希（Hash）表
简单地，使用一个下标范围比较大的数组来存储元素。设计一个函数（哈希函数），通过此函数，计算每个关键字的对应的值（数组下标），用这个数组单元来存储这个元素。

请看一题： 设哈希函数为 H(key)= key mod 9,关键字序列为：23,45,14,17,9,29,37,18,25,41,33.采用链地址法解决冲突。请画出哈希表。 解：先根据散列函数计算各关键字对应的 Hash 地址，然后采用链地址法解决冲突，构造的哈希表如下：

2 HashMap 底层原理

2.1 基本源码

以 JDK1.8 为例，HashMap 源码：

package java.util;
public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    // 默认的初始化容量值，大小必须为2的幂次方
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    // 最大容量值
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //装填因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    //存储元素数组，Node是个内部类
    transient Node<K,V>[] table;

    //构造方法，也是经常一般小白经常使用的方法
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

    //带容量的构造方法，建议使用
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    //...其他
}

数组中的元素也称之为哈希桶，即 Node 这个类具体对象实例，其源码如下：

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

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

每个 Node 节点元素中包含了四个字段：hash、key、value、next，其中 next 表示链表的下一个节点。

2.2 如何构造哈希函数

查看 API 源码，哈希方法如下：

static final int hash(Object key) {
        int h;
        //哈希值进行异或运算
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

两个 hashCode 值（(h = key.hashCode()) ^ (h >>> 16)）进行异或运算，目的是可以将 hashCode 高位和低位的值进行异或运算，这样生成的哈希值的随机性会增大，产生冲突的可能性小。

2.3 如何处理冲突

HashMap 的底层基于数组和链表及红黑树实现，所以 HashMap 底层主要是通过链地址法即来解决 hash 冲突的，具体通过单链表和红黑树两种数据结构来处理冲突。

具体来看下 hash 表中插入元素源码：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //如果table为空，或者满了，则调用resize方法扩容
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;

        //获取插入table的位置
        if ((p = tab[i = (n - 1) & hash]) == null)
            //没产生冲突，直接插入
            tab[i] = newNode(hash, key, value, null);
        else {
            //冲突处理，有两种情况，1、key值相同时直接更新value值，
            //2、key值不一样时，链表和红黑树处理
            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;
    }

哈希冲突发生的几种情况：

两个 Node 节点的 key 值相同（hash 值一定相同，因为重写了 hash 方法），发生冲突；
两个 Node 节点的 key 值不同，由于 hash 函数的局限性导致 hash 值相同，发生冲突；
两个 Node 节点的 key 值不同，hash 值不同，但 hash 值对数组长度取模后相同，发生冲突；

3 常见面试题

3.1 装载因子为什么是 0.75？

装载因子也叫加载因子，依据此值来触发 Hash 表是否需要扩容，假设加载因子为 0.5，HashMap 的初始化容量是 16，那么当 HashMap 中有 16*0.5=8 个元素时，HashMap 就会进行扩容。
加载因子为什么是 0.75 而不是 0.5 或者 1.0 ？

当加载因子设置比较大的时候，扩容的门槛就被提高了，扩容发生的频率比较低，占用的空间会比较小，但此时发生 Hash 冲突的几率就会提升，因此需要更复杂的数据结构来存储元素，这样对元素的操作时间就会增加，运行效率也会因此降低；
当加载因子值比较小的时候，扩容的门槛会比较低，因此会占用更多的空间，此时元素的存储就比较稀疏，发生哈希冲突的可能性就比较小，因此操作性能会比较高。综上：出于容量和性能之间平衡的考虑，取中间值 0.75 作为加载因子

3.2 重写 equals 方法为什么必须要重写 hashCode 方法？

为了保证当两个对象通过 equals()方法比较相等时，其 hashCode 值也一定要保证相等。
如果对一个对象重写了 euqals 方法，说明意图是只要对象的成员变量值都相等，那么两个对象 equals 时就等于 true，但如果不重写 hashCode，那么再 new 一个新的对象，当原对象.equals（新对象）等于 true 时，两者的 hashCode 却是不一样的，由此将产生了理解的不一致，容易导致混淆。

直接撸一把源码：

Student 类实现的 HashCode 方法注释掉
往 HashMap 中 put 存放 Student 类对象

class Student {
    private String name;

    public Student (String name) {
        this.name = name;
    }

    @Override
    public String toString(){
        return this.name;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Student ) {
            Student name = (Student) obj;
            System.out.println("equals method .. "+ name.name);
            return (this.name.equals(name.name));
        }
        return super.equals(obj);
    }

   /* @Override
    public int hashCode() {
        Student student = (Student) this;
        System.out.println("hashCode method .. " + student.name);
        return this.name.hashCode();
    }*/
}


public class Codingwbp {
    public static void main(String[] args) {
        Student stu1 = new Student("01");
        Student stu2 = new Student("01");
        HashMap<Student,String> map = new HashMap<>(2);
        map.put(stu1,"我是student1，HashMap没懂了啊，Coding我不配");
        map.put(stu2,"我是student2，HashMap看懂了，奥利给！");
        System.out.println("map size .. " + map.size());
    }
}

map size .. 2

运行结果分析：其实想得到的结果是 map 中只有一个元素，因为 Student 类重写了 equals 方法，即只要 name 相同即为 true，这样导致理解不一致。

3.3 JDK 1.8 HashMap 做了哪些优化？

扩容优化，即 resize()方法优化。重写此方法后不需要重新计算 hash，只需要根据原来 hash 值新增的 bit 是 1 还是 0 分别放进两个链表 low 和 high（非红黑树的情况）里，0 的话索引没变，1 的话索引变为原索引加原来的数组长度。
引入了红黑树，目的是避免单条链表过长而影响查询效率。利用红黑树快速增删改查的特点提高 HashMap 的性能。
解决了 resize 时多线程死循环问题，因为用的尾插法所以新数组链表不会倒置，多线程下不会出现死循环；但仍是非线程安全的。

欢迎关注公众号：Coding我不配 | 获取更多干货，一起每天进步一点点

http://weixin.qq.com/r/IkxHXyrE13eorW489xkw (二维码自动识别)

weixin_39743423

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
hashmap原理_小白定能看懂的HashMap实现原理

1 散列查找先来回顾一下数据结构查找知识点—散列（哈希）查找查找定义：给定某个目标值，在数据集中确定一个其关键字等于目标值的数据元素的位置散列查找：关键字与在数据集中的位置一一对应，通过此对应关系能快速地找到目标值所在的位置。散列查找前提是要构造哈希表，构造哈希表主要包含两部分：散列函数的构造和处理冲突的方法。什么是哈希（Hash）表简单地，使用一个下标范围比较大的数组来存储元素。设计一个函数...
复制链接

扫一扫