HashMap和LinkedHashMap源码阅读

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量100 收藏
点赞数
分类专栏： Java源码阅读 文章标签： java hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40633659/article/details/120071333
版权

HashMap和LinkedHashMap

1. HashMap

1.1 key值hash的计算

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

​ int - 4字节共32位，用高16位与低16进行异或运算，充分利用hashCode函数返回的int值，降低了hash冲突的概率

​ 默认容量16，计算table下标方法为 （16-1）& hash值，即取出hash值的低四位，16 - 1二进制表示为1111

1.2 put方法

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

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;  // 第一次插入数据，进行resize()初始化
    if ((p = tab[i = (n - 1) & hash]) == null) // 计算要放入的桶索引：(n - 1) & hash
        tab[i] = newNode(hash, key, value, null); // 若为空，新创建一个节点
    else { // 桶的头节点不为空
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k)))) 
            e = p; // 头节点key值与要插入的元素相同，equals和==双判断
        else if (p instanceof TreeNode) //如果头节点为TreeNode类型，进行红黑树的插入操作
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else { //该桶节点为普通链表类型
            for (int binCount = 0; ; ++binCount) { //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;  // 遇到key相同直接跳出循环，后面进行value覆盖处理
                p = e; //链表便利
            }
        }
      	// 发现与要插入Map元素key值相同的元素，覆盖旧值
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);  // LinkedHashMap进行方法重写，accessOrder为true时进行会将e元素放到双向链表的尾部
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold) //扩容判断，threshold值为扩容阈值（eg: 16 * 0.75 = 12）
        resize(); 
    afterNodeInsertion(evict); //LinkedHashMap会进行重写，可能会进行remove eldest元素
    return null;
}

1.3 get方法

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;
  if ((tab = table) != null && (n = tab.length) > 0 &&
      (first = tab[(n - 1) & hash]) != null) { //first获取hash对应的桶索引节点
    if (first.hash == hash && // always check first node
        ((k = first.key) == key || (key != null && key.equals(k))))
      return first;
    if ((e = first.next) != null) {
      if (first instanceof TreeNode)
        return ((TreeNode<K,V>)first).getTreeNode(hash, key);
      do {
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
          return e;
      } while ((e = e.next) != null);  // 循环遍历链表，寻找key相同的节点
    }
  }
  return null;
}


public boolean containsKey(Object key) {
  return getNode(hash(key), key) != null;
}

1.4 resize()扩容方法

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length; //旧容量（数组长度）
        int oldThr = threshold; //旧扩容阈值
        int newCap, newThr = 0;
        if (oldCap > 0) {
          	//MAXIMUM_CAPACITY（最大容量，2的30次方）：a power of two <= 1<<30.
            if (oldCap >= MAXIMUM_CAPACITY) { 
                threshold = Integer.MAX_VALUE; //无法继续进行X2扩容，可插入的元素最大数目调整至Integer最大值
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && 
                     oldCap >= DEFAULT_INITIAL_CAPACITY)  // cap进行X2扩容
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr; //构造函数中指定loadfactor和初始cap
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY; //16
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //12 = 16 * 0.75f
        }
        if (newThr == 0) { //构造函数中指定loadfactor和初始cap, 计算新的扩容阈值
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr; 
        @SuppressWarnings({"rawtypes","unchecked"})
        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) { //e为该桶下头节点
                    oldTab[j] = null;
                    if (e.next == null) //该桶只有一个元素
                        newTab[e.hash & (newCap - 1)] = e; //计算e节点在新容量下的对应的桶索引，修改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) { 
                              //e.hash & oldCap 如果为0说明：e.hash与newCap-1异或运算结果还是j
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else { 
                              //e.hash & oldCap 如果为1说明：e.hash与newCap-1异或运算结果不再是j，而是j+oldCap
                                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;
    }

2. LinkedHashMap(继承于HashMap)

image-20210902215417847

2.1构造方法

accessOrder – the ordering mode - true for access-order, false for insertion-order

Access-order: 表示访问过节点会放到双向链表的尾部

Insertion-order: 按插入顺序排列双向链表

public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
}

2.2 newNode函数

  • LinkedHashMap结构图：

    image-20210902220601866

//LinkedHashMap中Entry节点中加入before和after指针    
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);
        }
    }


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);
    linkNodeLast(p); //将new的节点加入双向链表尾部
    return p;
}
// link at the end of list
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
    LinkedHashMap.Entry<K,V> last = tail;
    tail = p; //Update tail为新建的节点p
    if (last == null)
      head = p;
    else {
      p.before = last;
      last.after = p;
    }
}

2.3 重写的方法

  • get方法

    public V get(Object key) {
        Node<K,V> e;
        if ((e = getNode(hash(key), key)) == null)
            return null;
        if (accessOrder)
            afterNodeAccess(e);
        return e.value;
    }

    accessOrder为true时，调用afterNodeAccess方法

  • afterNodeAccess()，访问过e节点后会调用该方法，将访问过的节点移动到尾部

    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;
            if (b == null)
                head = a;
            else
                b.after = a;
            if (a != null)
                a.before = b;
            else
                last = b;
            if (last == null)
                head = p;
            else {
                p.before = last;
                last.after = p;
            }
            tail = p;
            ++modCount;
        }
    }

  • afterNodeInsertion方法，在插入元素后会进行调用，可能会移除头部的元素

    移除条件：removeEldestEntry方法进行重写，例如写为 return size() > 常量；在需要进行移除的时候返回true，默认返回false，不进行移除操作

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


		protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }

  • afterNodeRemoval方法，会在移除节点后进行调用，从链表中remove，unlink

        void afterNodeRemoval(Node<K,V> e) { // unlink
        LinkedHashMap.Entry<K,V> p =
            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
        p.before = p.after = null;
        if (b == null)
            head = a;
        else
            b.after = a;
        if (a == null)
            tail = b;
        else
            a.before = b;
    }

3. LinkedHashMap实现LRU缓存

package edu.swjtu.lxd;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Random;

public class LRU<K, V> extends LinkedHashMap<K, V> implements Map<K, V> {

    public static final long serialVersionUID = 1L;

    private int MAX_CACHE = 10;
    public LRU(int initialCapacity, float loadFactor, int maxCache) {
        super(initialCapacity, loadFactor, true);
        MAX_CACHE = maxCache;
    }
    public LRU(int maxCache) {
        super(16, 0.75f, true);
        MAX_CACHE = maxCache;
    }

    @Override
    protected boolean removeEldestEntry(Entry<K, V> eldest) { //重写方法
        return size() > MAX_CACHE;
    }

    public static void main(String[] args) {
        Random random = new Random();
        LRU<Integer, String> lruCache = new LRU<>(6);
        for(int i = 0; i < 10; i++) {
            lruCache.put(i + random.nextInt(10), "a" + i);
        }
        System.out.println(lruCache.size());
        System.out.println(lruCache);
    }
}

image-20210902223332435

Seldon1224
关注
专栏目录
【Java集合框架】篇五：HashMap、LinkedHashMap源码解析
酷奇的博客
03-03 879
jdk8中，我们调用空参构造器，创建实例时，底层没用立即初始化数组容量，在我们第一次put元素时，才初始化一个容量为16的数组table，并将元素添加到table（类似懒汉式） jdk8中，将内部类Entry改名为Node（名称合理化），意味着我们创建的数组式Node[]，不再是Entry[]。 jdk8中，key1和key2的哈希值和内容不同，则(key1,value1)与(key2,value3)构成单向链表，(key2,value2)指向(key1,value1)（尾插法）。因为头插法在多线程的情况下
深入理解HashMap和LinkedHashMap的区别
vx539413949的博客
04-30 2006
简介 我们知道HashMap的变量顺序是不可预测的，这意味着便利的输出顺序并不一定和HashMap的插入顺序是一致的。这个特性通常会对我们的工作造成一定的困扰。为了实现这个功能，我们可以使用LinkedHashMap。 LinkedHashMap详解 先看下LinkedHashMap的定义： public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V> LinkedHas
LRU与LinkedHashMap的不解情缘
梁海江的博客
01-05 304
1.前言 最近在学习Mybatis源码关于一级和二级缓存的过程中，有这么一个类，LruCache.class。按照设计模式来说这里用到了装饰者的设计模式，维护一个接口类【Cache delegate;】的变量。当然这不是重点，重点是他有一个成员变量，keyMap，实例化对象是LinkedHashMap。更要紧的是，他在创建这个对象的时候，还重写了removeEldestEntry这个方法（如下代...
Java集合（六）LinkedHashMap详解
qq_41969790的博客
05-16 6794
本文目录 1 LinkedHashMap概述 2 LinkedHashMap 源码定义 2.1 类结构定义 2.2成员变量定义 2.3 成员方法定义 2.4 基本元素 Entry 3 LinkedHashMap的方法 3.1 LinkedHashMap的构造方法 3.2 初始化方法init方法 3.3 LinkedHashMap的快速存取 3.3.1LinkedHashMap 的存储实现 : put(key, vlaue) 3.3.2 LinkedHashMap 的扩容操作 : ..
LRU缓存算法-基于LinkedHashMap实现
weixin_33713350的博客
03-24 108
2019独角兽企业重金招聘Python工程师标准>>> ...
JAVA集合-线程安全
Lyajpunov的博客
01-25 3263
一、其他的集合类 我们这里来介绍一点其他的集合类 1.1、Linkedhashmap Linkedhashmap在原来的基础上维护了一个双向链表，用来维护，插入的顺序。 public class LinkedHashMapTest { public static void main(String[] args){ Map<String,String> map = new LinkedHashMap<>(16); map.put("a","m"
Java集合详解5：深入理解LinkedHashMap和LRU缓存
热门推荐
Java技术江湖
05-12 3万+
今天我们来深入探索一下LinkedHashMap的底层原理，并且使用linkedhashmap来实现LRU缓存。 具体代码在我的GitHub中可以找到 https://github.com/h2pl/MyTech 文章首发于我的个人博客： https://h2pl.github.io/2018/05/11/collection5 更多关于Java后端学习的内容请到我的CSDN博客上查看：...
彻底理解HashMap及LinkedHashMap
qq_14958051的博客
07-05 983
作者：GeorgiaStarblog.csdn.net/fuzhongmin05/article/details/104355841HashMap是Map族中最为常用的一种，也是Java ...
深入理解JDK1.8中HashMap,LinkedHashMap源码及设计思路
CallmeZhe的博客
11-28 209
目录 (一)HashMap,LinkedHashMap的关系 (二)加载因子的作用和默认的加载因子为什么是0.75f (三)为什么哈希表的容量（数组长度）是2的整数次幂 (四)put操作的实现源码及设计思路 HashMap中put LinkedHashMap中put (五)get操作的实现源码及设计思路 HashMap中get LinkedHashMap中get (六)怎么进行扩容 (七)HashMap是怎么解决hash冲突的 之前有分析过1.8之前的HashMap源码，今天再来看看
HashMap与LinkedHashMap
Spground
11-19 776
HashMap与LinkedHashMap 简介 二者的区别 源码阅读 Best PracticesHashMap与LinkedHashMap1. 简介在日常开发中我们经常会批量操作数据，因此很多高级语言除了提供数组，还给我们提供很多高级的、抽象的数据类型来让我们处理批量数据时得心应手。由于这些轮子对于程序的性能是比较关键的轮子，因此很多语言都内置的提供了比较精致的实现。在java中，这种实现被称为
集合-LinkedHashMap源码详解（特有方法解析）以及HashMap与LinkedHashMap的不同
Fly_Fly_Zhang的博客
02-27 1108
特点： 底层数据结构：数组加链表用来存储数据； header双向链表用来实现数据插入有序或者访问有序； 继承关系： public class LinkedHashMap&amp;amp;lt;K,V&amp;amp;gt; extends HashMap&amp;amp;lt;K,V&amp;amp;gt; //继承了HashMap implements Map&amp;amp;lt;K,V&amp;amp;gt;//实现了Map接口 {
LRU算法还一知半解？
weixin_33775582的博客
12-21 119
某年某月某日，糖葫芦同学在掘金app上看了几篇文章，偶然看到了一篇熟悉的词LRU算法，脑海里就想这不是经常说的嘛，就那么回事，当天晚上睡觉，LRU算法是啥来着，好像是什么最近最少使用的，白天在地铁上看的文章也不少，但是到晚上想想好像啥也没记住，就记得LRU算法，我发现人大多数是这样的啊，对于自己熟悉的部分呢还能记着点，不熟悉或者不会的可能真的是看过就忘啊~既然这样还不如先把熟悉的弄明白。 第二...
Java 集合深入理解 （十六） ：LinkedHashMap 实现原理深入 、以及推荐使用建立lru缓存
踩踩踩从踩的博客
06-08 1024
前言 LinkedHashMap 是hashmap和双向链表结合的一种数据结构，用于记录插入顺序，并在迭代器进行取出数据时顺序和插入数据相同；LinkedHashMap可以很好的支持LRU算法
彻头彻尾理解 LinkedHashMap
weixin_44767512的博客
04-17 260
一. LinkedHashMap 概述 HashMap 是 Java Collection Framework 的重要成员，也是Map族(如下图所示)中我们最为常用的一种。不过遗憾的是，HashMap是无序的，也就是说，迭代HashMap所得到的元素顺序并不是它们最初放置到HashMap的顺序。HashMap的这一缺点往往会造成诸多不便，因为在有些场景中，我们确需要用到一个可以保持插入顺序的Map...
LinkedHashMap 排序模式accessOrder-----LRU算法
lansefanggezi123的博客
03-16 2142
在看LinkedHashMap源码时，可以发现读取操作的get（）方法很有意思。 代码如下 public V get(Object key) { Entry&lt;K,V&gt; e = (Entry&lt;K,V&gt;)getEntry(key); if (e == null) return null; e.r...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1240
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 937
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 365
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 706
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值