Java常用集合类(1)-HashMap/LinkedHashM

作者: 嘎嘣脆糖 | 来源:发表于2020-02-06 15:31 被阅读0次

    在开发中,经常会用到一些集合类去作为数据存储的容器,比如通常我们想要以key-value/键值对的形式存储数据的时候,最常用的就是HashMap。

    HashMap

    继承自AbstractMap并实现了Map接口,采用数组和链表的方式存储元素(java 1.8之后,当链表长度超过8的时候,会将链表转成红黑树,用来增加查询效率)。


    数据结构

    构造函数

        /**
         * The default initial capacity - MUST be a power of two.
         */
        static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    
        /**
         * The load factor used when none specified in constructor.
         */
        static final float DEFAULT_LOAD_FACTOR = 0.75f;
        /**
         * Constructs an empty <tt>HashMap</tt> with the specified initial
         * capacity and load factor.
         *
         * @param  initialCapacity the initial capacity
         * @param  loadFactor      the load factor
         * @throws IllegalArgumentException if the initial capacity is negative
         *         or the load factor is nonpositive
         */
        public HashMap(int initialCapacity, float loadFactor) {
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal initial capacity: " +
                                                   initialCapacity);
            if (initialCapacity > MAXIMUM_CAPACITY)
                initialCapacity = MAXIMUM_CAPACITY;
            if (loadFactor <= 0 || Float.isNaN(loadFactor))
                throw new IllegalArgumentException("Illegal load factor: " +
                                                   loadFactor);
            this.loadFactor = loadFactor;
            this.threshold = tableSizeFor(initialCapacity);
        }
    

    Hashmap 有很多的构造函数,我们最常用的构造函数就是空参构造也就是以 new HashMap();这种形式去构造出一个默认initialCapacity为16,loadFactor为0.75的HashMap

    initialCapacity

    顾名思义 初始容量,默认是16,注释也说明了必须是2的n次方才可以,如果不是会帮你转成2的n次方,由于HashMap的扩容rresize()和hash计算比较耗费性能,所以当使用时能确定容量大小的话,可以直接指定大小
    The default initial capacity - MUST be a power of two.

    loadFactor

    扩容因子
    当存储容量到达当前容量多少的时候选择进行扩容,默认是0.75,拿默认值来说,16*0.75 =12,所以当使用无参构造创建的hashmap创建的对象,当存储对象超过12个的时候,将进行扩容,每次扩容为上次容量的2倍。

    查找 get(K key)

    HashMap的查找首先定位键值对所在数组中的位置,然后再对红黑树和链表进行查找。

    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
    
    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        // 1. 定位键值对所在桶的位置
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                // 2. 如果 first 是 TreeNode 类型,则调用黑红树查找方法
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                    
                // 2. 对链表进行查找
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }
    

    其中(n - 1) & hash用来计算index,由于HashMap 中桶数组的大小 length 总是2的幂,此时,(n - 1) & hash 等价于对 length 取余。

    存储键值对 put(K key, V value);

        public V put(K key, V value) {
            //调用了putVal()方法,并计算出key的hash值
            return putVal(hash(key), key, value, false, true);
        }
    
        static final int hash(Object key) {
            int h;
            //通过key的hashcode异或计算出hash值,详细的算法说明见下文链接,主要目的是为了减少hash碰撞使,存储分布更加均匀,前提是容量大小为2的n次方
            return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
        }
    
     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;
            //计算数组中存储的位置,如果为null,则直接存放,其中 (n - 1) & hash用来计算数组的index,相当于取模%运算,因为二进制的位运算效率高所以容量大小设计为2的n次方,index计算可以直接采用位运算来提升效率
            if ((p = tab[i = (n - 1) & hash]) == null)
                tab[i] = newNode(hash, key, value, null);
            else {
                Node<K,V> e; K k;
                //如果该index下存在值则替换
                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;
        }
    

    关于hashmap中的hash算法,可以参考:hash算法

    插入操作主要做了下面几项工作:

    • 当桶数组 table 为空时,通过扩容的方式初始化 table
    • 查找要插入的键值对是否已经存在,存在的话根据条件判断是否用新值替换旧值
    • 如果不存在,则将键值对链入链表中,并根据链表长度决定是否将链表转为红黑树
    • 判断键值对数量是否大于阈值,大于的话则进行扩容操作

    扩容机制

    在 HashMap 中,桶数组的长度均是2的幂,阈值大小为桶数组长度与负载因子的乘积。当 HashMap 中的键值对数量超过阈值时,进行扩容。

    HashMap 按当前桶数组长度的2倍进行扩容,阈值也变为原来的2倍(如果计算过程中,阈值溢出归零,则按阈值公式重新计算)。扩容之后,要重新计算键值对的位置,并把它们移动到合适的位置上去。以上就是 HashMap 的扩容大致过程,接下来我们来看看具体的实现:

    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        // 如果 table 不为空,表明已经初始化过了
        if (oldCap > 0) {
            // 当 table 容量超过容量最大值,则不再扩容
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            } 
            // 按旧容量和阈值的2倍计算新容量和阈值的大小
            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
            /*
             * 初始化时,将 threshold 的值赋值给 newCap,
             * HashMap 使用 threshold 变量暂时保存 initialCapacity 参数的值
             */ 
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            /*
             * 调用无参构造方法时,桶数组容量为默认容量,
             * 阈值为默认容量与默认负载因子乘积
             */
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        
        // newThr 为 0 时,按阈值计算公式进行计算
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        // 创建新的桶数组,桶数组的初始化也是在这里完成的
        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;
                                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;
    }
    
    • 计算新桶数组的容量 newCap 和新阈值 newThr
    • 根据计算出的 newCap 创建新的桶数组,桶数组 table 也是在这里进行初始化的
    • 将键值对节点重新映射到新的桶数组里。如果节点是 TreeNode 类型,则需要- - 拆分红黑树。如果是普通节点,则节点按原顺序进行分组。

    LinkedHashMap

    LinkedHashMap 继承自HashMap实现了Map接口,底层数据结构实现相对于HashMap多了双向链表,用来记录数据存储的顺序,可分为两种类型,一个是按照存储顺序来进行存储,另一种是按照访问顺序存储,根据这个我们可以实现一个简单的LRUCache

    构造函数

        /**
         * Constructs an empty insertion-ordered <tt>LinkedHashMap</tt> instance
         * with the specified initial capacity and load factor.
         *
         * @param  initialCapacity the initial capacity
         * @param  loadFactor      the load factor
         * @throws IllegalArgumentException if the initial capacity is negative
         *         or the load factor is nonpositive
         */
        public LinkedHashMap(int initialCapacity,
                             float loadFactor,
                             boolean accessOrder) {
            super(initialCapacity, loadFactor);
            this.accessOrder = accessOrder;
        }
        public LinkedHashMap(int initialCapacity, float loadFactor) {
            super(initialCapacity, loadFactor);
            accessOrder = false;
        }
    
        public LinkedHashMap(int initialCapacity) {
            super(initialCapacity);
            accessOrder = false;
        }
    
        public LinkedHashMap() {
            super();
            accessOrder = false;
        }
    

    和HashMap一样,LinkedHashMap的初始容量为16,扩容因子为0.75,默认的存储顺序为,存储顺序。

    插入

    在LinkedHashMap中并没有重写put方法,而是重写了newNode()方法,进行双向链表的链接

    
    // HashMap 中实现
    Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
        return new Node<>(hash, key, value, next);
    }
    
    // LinkedHashMap 中覆写
    Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
        LinkedHashMap.Entry<K,V> p =
            new LinkedHashMap.Entry<K,V>(hash, key, value, e);
        // 将 Entry 接在双向链表的尾部
        linkNodeLast(p);
        return p;
    }
    
    // LinkedHashMap 中实现
    private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
        LinkedHashMap.Entry<K,V> last = tail;
        tail = p;
        // last 为 null,表明链表还未建立
        if (last == null)
            head = p;
        else {
            // 将新节点 p 接在链表尾部
            p.before = last;
            last.after = p;
        }
    }
    

    get()

    LinkedHashMap在获取元素的时候回根据访问顺序去排列双向链表的顺序

    // LinkedHashMap 中覆写
    public V get(Object key) {
        Node<K,V> e;
        if ((e = getNode(hash(key), key)) == null)
            return null;
        // 如果 accessOrder 为 true,则调用 afterNodeAccess 将被访问节点移动到链表最后
        if (accessOrder)
            afterNodeAccess(e);
        return e.value;
    }
    
    // LinkedHashMap 中覆写
    void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        if (accessOrder && (last = tail) != e) {
            LinkedHashMap.Entry<K,V> p =
                (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            p.after = null;
            // 如果 b 为 null,表明 p 为头节点
            if (b == null)
                head = a;
            else
                b.after = a;
                
            if (a != null)
                a.before = b;
            /*
             * 这里存疑,父条件分支已经确保节点 e 不会是尾节点,
             * 那么 e.after 必然不会为 null,不知道 else 分支有什么作用
             */
            else
                last = b;
        
            if (last == null)
                head = p;
            else {
                // 将 p 接在链表的最后
                p.before = last;
                last.after = p;
            }
            tail = p;
            ++modCount;
        }
    }
    

    最后,如果想要基于LinkedHashMap实现缓存则需要重写如下方法

    // 移除最近最少被访问条件之一,通过覆盖此方法可实现不同策略的缓存
    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }
    

    最后奉上完整代码:即为leetcode中的146题,含有jeromememory写的解释,非常清晰

    HashMap 大家都清楚,底层是 数组 + 红黑树 + 链表 (不清楚也没有关系),同时其是无序的,而 LinkedHashMap 刚好就比 HashMap 多这一个功能,就是其提供 有序,并且,LinkedHashMap的有序可以按两种顺序排列,一种是按照插入的顺序,一种是按照读取的顺序(这个题目的示例就是告诉我们要按照读取的顺序进行排序),而其内部是靠 建立一个双向链表 来维护这个顺序的,在每次插入、删除后,都会调用一个函数来进行 双向链表的维护 ,准备的来说,是有三个函数来做这件事,这三个函数都统称为 回调函数 ,这三个函数分别是:

    void afterNodeAccess(Node<K,V> p) { }
    

    其作用就是在访问元素之后,将该元素放到双向链表的尾巴处(所以这个函数只有在按照读取的顺序的时候才会执行),之所以提这个,是建议大家去看看,如何优美的实现在双向链表中将指定元素放入链尾!

    void afterNodeRemoval(Node<K,V> p) { }
    

    其作用就是在删除元素之后,将元素从双向链表中删除,还是非常建议大家去看看这个函数的,很优美的方式在双向链表中删除节点!

    void afterNodeInsertion(boolean evict) { }
    

    这个才是我们题目中会用到的,在插入新元素之后,需要回调函数判断是否需要移除一直不用的某些元素!
    其次,我再介绍一下 LinkedHashMap 的构造函数!
    其主要是两个构造方法,一个是继承 HashMap ,一个是可以选择 accessOrder 的值(默认 false,代表按照插入顺序排序)来确定是按插入顺序还是读取顺序排序。

    /**
     * //调用父类HashMap的构造方法。
     * Constructs an empty insertion-ordered <tt>LinkedHashMap</tt> instance
     * with the default initial capacity (16) and load factor (0.75).
     */
    public LinkedHashMap() {
        super();
        accessOrder = false;
    }
    // 这里的 accessOrder 默认是为false,如果要按读取顺序排序需要将其设为 true
    // initialCapacity 代表 map 的 容量,loadFactor 代表加载因子 (默认即可)
    public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }
    

    思路 & 代码
    下面是我自己在分析 LinkedHashMap 源码时做的一些笔记,应该是比较清楚的,主体意思就是我们要继承 LinkedHashMap,然后复写 removeEldestEntry()函数,就能拥有我们自己的缓存策略!

    // 在插入一个新元素之后,如果是按插入顺序排序,即调用newNode()中的linkNodeLast()完成
    // 如果是按照读取顺序排序,即调用afterNodeAccess()完成
    // 那么这个方法是干嘛的呢,这个就是著名的 LRU 算法啦
    // 在插入完成之后,需要回调函数判断是否需要移除某些元素!
    // LinkedHashMap 函数部分源码
    
    /**
     * 插入新节点才会触发该方法,因为只有插入新节点才需要内存
     * 根据 HashMap 的 putVal 方法, evict 一直是 true
     * removeEldestEntry 方法表示移除规则, 在 LinkedHashMap 里一直返回 false
     * 所以在 LinkedHashMap 里这个方法相当于什么都不做
     */
    void afterNodeInsertion(boolean evict) { // possibly remove eldest
        LinkedHashMap.Entry<K,V> first;
        // 根据条件判断是否移除最近最少被访问的节点
        if (evict && (first = head) != null && removeEldestEntry(first)) {
            K key = first.key;
            removeNode(hash(key), key, null, false, true);
        }
    }
    
    // 移除最近最少被访问条件之一,通过覆盖此方法可实现不同策略的缓存
    // LinkedHashMap是默认返回false的,我们可以继承LinkedHashMap然后复写该方法即可
    // 例如 LeetCode 第 146 题就是采用该种方法,直接 return size() > capacity;
    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }
    

    通过上述代码,我们就已经知道了只要复写 removeEldestEntry() 即可,而条件就是 map 的大小不超过 给定的容量,超过了就得使用 LRU 了!然后根据题目给定的语句构造和调用:

    /**
     * LRUCache 对象会以如下语句构造和调用:
     * LRUCache obj = new LRUCache(capacity);
     * int param_1 = obj.get(key);
     * obj.put(key,value);
     */
    

    很明显我们只需要直接继承父类的put函数即可,因为题目没有特殊要求,故可以不写!至于 get() 函数,题目是有要求的!

    获取数据 get(key) - 如果密钥 (key) 存在于缓存中,则获取密钥的值(总是正数),否则返回 -1。

    所以我们可以调用 LinkedHashMap 中的 getOrDefault(),完美符合这个要求,即当key不存在时会返回默认值 -1。

    至此,我们就基本完成了本题的要求,只要写一个构造函数即可,答案的 super(capacity, 0.75F, true);,没看过源码的小伙伴可能不太清楚这个构造函数,这就是我上文讲的 LinkedHashMap 中的常用的第二个构造方法,具体大家可以看我上面代码的注释!

    至此,大功告成!

    class LRUCache extends LinkedHashMap<Integer, Integer>{
        private int capacity;
        
        public LRUCache(int capacity) {
            super(capacity, 0.75F, true);
            this.capacity = capacity;
        }
    
        public int get(int key) {
            return super.getOrDefault(key, -1);
        }
    
        // 这个可不写
        public void put(int key, int value) {
            super.put(key, value);
        }
    
        @Override
        protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
            return size() > capacity; 
        }
    }
    

    最后,附上我最开始讲的那两个函数的源码以及部分自己的解析

    //标准的如何在双向链表中将指定元素放入队尾
    // LinkedHashMap 中覆写
    //访问元素之后的回调方法
    
    /**
     * 1. 使用 get 方法会访问到节点, 从而触发调用这个方法
     * 2. 使用 put 方法插入节点, 如果 key 存在, 也算要访问节点, 从而触发该方法
     * 3. 只有 accessOrder 是 true 才会调用该方法
     * 4. 这个方法会把访问到的最后节点重新插入到双向链表结尾
     */
    void afterNodeAccess(Node<K,V> e) { // move node to last
        // 用 last 表示插入 e 前的尾节点
        // 插入 e 后 e 是尾节点, 所以也是表示 e 的前一个节点
        LinkedHashMap.Entry<K,V> last;
        //如果是访问序,且当前节点并不是尾节点
        //将该节点置为双向链表的尾部
        if (accessOrder && (last = tail) != e) {
            // p: 当前节点
            // b: 前一个节点
            // a: 后一个节点
            // 结构为: b <=> p <=> a
            LinkedHashMap.Entry<K,V> p =
                (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            // 结构变成: b <=> p <- a
            p.after = null;
    
            // 如果当前节点 p 本身是头节点, 那么头结点要改成 a
            if (b == null)
                head = a;
            // 如果 p 不是头尾节点, 把前后节点连接, 变成: b -> a
            else
                b.after = a;
    
            // a 非空, 和 b 连接, 变成: b <- a
            if (a != null)
                a.before = b;
            // 如果 a 为空, 说明 p 是尾节点, b 就是它的前一个节点, 符合 last 的定义
            // 这个 else 没有意义,因为最开头if已经确保了p不是尾结点了,自然after不会是null
            else
                last = b;
    
            // 如果这是空链表, p 改成头结点
            if (last == null)
                head = p;
            // 否则把 p 插入到链表尾部
            else {
                p.before = last;
                last.after = p;
            }
            tail = p;
            ++modCount;
        }
    }
    void afterNodeRemoval(Node<K,V> e) { // 优美的一笔,学习一波如何在双向链表中删除节点
        LinkedHashMap.Entry<K,V> p =
            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
        // 将 p 节点的前驱后后继引用置空
        p.before = p.after = null;
        // b 为 null,表明 p 是头节点
        if (b == null)
            head = a;
        else
            b.after = a;
        // a 为 null,表明 p 是尾节点
        if (a == null)
            tail = b;
        else
            a.before = b;
    }
    

    相关文章

      网友评论

        本文标题:Java常用集合类(1)-HashMap/LinkedHashM

        本文链接:https://www.haomeiwen.com/subject/tppyxhtx.html