LinkedHashMap

最新推荐文章于 2022-05-15 19:44:12 发布
最新推荐文章于 2022-05-15 19:44:12 发布
阅读量381 收藏
点赞数 1
分类专栏： java基础 集合类 文章标签： java基础 java集合类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NowUSeeMe/article/details/62886928
版权

本文基于JDK1.8

一、概述

1. 继承体系

在这里插入图片描述
在这里插入图片描述
HashMap 是 Java集合Collection的重要成员，如上图所示，也是Map家族中我们最为常用的一种。不过遗憾的是，HashMap是无序的，也就是说，迭代HashMap所得到的元素顺序并不是它们最初放置到HashMap的顺序。HashMap的这一缺点往往会造成诸多不便，因为在有些场景中，我们确需要用到一个可以保持插入顺序的Map。庆幸的是，JDK为我们解决了这个问题，它为HashMap提供了一个子类 —— LinkedHashMap。

2. 存储结构

 虽然LinkedHashMap增加了时间和空间上的开销，但是它通过维护一个额外的双向链表保证了迭代顺序。特别地，该迭代顺序可以是插入顺序，也可以是访问顺序。因此，根据链表中元素的顺序可以将LinkedHashMap分为：保持插入顺序的LinkedHashMap 和 保持访问顺序的LinkedHashMap，其中LinkedHashMap的默认实现是按插入顺序排序的。

本质上，HashMap和双向链表合二为一即是LinkedHashMap。所谓LinkedHashMap，其落脚点在HashMap，因此更准确地说，它是一个将所有Entry节点链入一个双向链表双向链表的HashMap。在LinkedHashMapMap中，所有put进来的Entry都保存在如下面第一个图所示的哈希表中，但由于它又额外定义了一个以head为头结点的双向链表，因此对于每次put进来Entry，除了将其保存到哈希表中对应的位置上之外，还会将其插入到双向链表的尾部。
HashMap和双向链表的密切配合和分工合作造就了LinkedHashMap。特别需要注意的是，next用于维护HashMap各个桶中的Entry链，before、after用于维护LinkedHashMap的双向链表，虽然它们的作用对象都是Entry，但是各自分离，是两码事儿。
在这里插入图片描述
其中，HashMap与LinkedHashMap的Entry结构示意图如下图所示：
在这里插入图片描述
特别地，由于LinkedHashMap是HashMap的子类，所以LinkedHashMap自然会拥有HashMap的所有特性。比如，LinkedHashMap也最多只允许一条Entry的键为Null(多条会覆盖)，但允许多条Entry的值为Null。此外，LinkedHashMap 也是 Map 的一个非同步的实现。
此外，LinkedHashMap还可以用来实现LRU (Least recently used, 最近最少使用)算法。主要关键点是accessOrder属性，当这个属性为true时，会把get()操作之后的K-V键值对，放在LinkedHashMap双向链表的末尾，当put操作且map容量不够时，LinkedHashMap会自动删除双向链表 表头的键值对，从而完成LRU算法

二、源码解析

1. 属性

/**
 * 双向链表头节点
 */
transient LinkedHashMap.Entry<K,V> head;

/**
 * 双向链表尾节点
 */
transient LinkedHashMap.Entry<K,V> tail;

/**
 * 迭代顺序。
 * true代表按访问顺序迭代
 * false代表按插入顺序迭代
 */
final boolean accessOrder;

LinkedHashMap.Entry 继承了HashMap的Node，并且每个entry都包含前指针和后指针，这是双向循环链表的特点。

/**
 * LinkedHashMap的Entry继承了HashMap的Node
 */
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的Node
// HashMap#Node
static class Node<K, V> implements Map.Entry<K, V> {
    final int hash;
    final K key;
    V value;
    Node<K, V> next;
}

在这里插入图片描述

accessOrder
是否需要按访问顺序排序，如果为false则按插入顺序存储元素，如果是true则按访问顺序存储元素，默认是false。

2. 构造方法

public LinkedHashMap(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor);
    accessOrder = false;
}

public LinkedHashMap(int initialCapacity) {
    super(initialCapacity);
    accessOrder = false;
}

public LinkedHashMap() {
    super();
    accessOrder = false;
}

public LinkedHashMap(Map<? extends K, ? extends V> m) {
    super();
    accessOrder = false;
    putMapEntries(m, false);
}

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

前四个构造方法accessOrder都等于false，说明双向链表是按插入顺序存储元素。
最后一个构造方法accessOrder从构造方法参数传入，如果传入true，则就实现了按访问顺序存储元素，这也是实现LRU缓存策略的关键。

3. 私有方法

linkNodeLast( LinkedHashMap.Entry<K,V> p)

/**
 * 将指定entry插入到双向链表末尾
 */
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
    LinkedHashMap.Entry<K,V> last = tail;
    //尾指针执行p
    tail = p;
    //如果旧的尾节点指向null，意味着双向循环链表为空，这时头尾指针都要指向p
    if (last == null)
        head = p;
    else {//否则将p插入到旧尾节点的后面
        p.before = last;
        last.after = p;
    }
}

transferLinks( LinkedHashMap.Entry<K,V> src, LinkedHashMap.Entry<K,V> dst)

// 将src替换为dst
private void transferLinks(LinkedHashMap.Entry<K,V> src,
                           LinkedHashMap.Entry<K,V> dst) {
    LinkedHashMap.Entry<K,V> b = dst.before = src.before;
    LinkedHashMap.Entry<K,V> a = dst.after = src.after;
    //如果src的前指针指向null，说明src为头节点，这时将dst替换为头节点即可
    if (b == null)
        head = dst;
    else//否则，将dst的前指针指向的节点的后指针指向dst
        b.after = dst;
    //如果src的后指针指向null，说明src为尾节点，这时将dst替换为尾节点即可
    if (a == null)
        tail = dst;
    else//否则，将dst的后指针指向的节点的前指针指向dst
        a.before = dst;
}

4. put(key, vlaue)方法

LinkedHashMap没有对 put(key,vlaue) 方法进行任何直接的修改，完全继承了HashMap的 put(Key,Value) 方法，HashMap#putput(Key,Value) 源码如下：

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;
    if ((p = tab[i = (n - 1) & hash]) == null)
        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;
        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中都是空方法，留给子类LinkedHashMap实现
 */
// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }

LinkedHashMap#put 方法 继承于父类 HashMap，对于HashMap#put方法本身，LinkedHashMap没有再进行重写，所以基本操作与HashMap的大体骨架无异。但是LinkedHashMap比 HashMap多了一个双向链表，所以在put操作中 HashMap几个钩子方法，LinkedHashMap做了补充重写。

(1) afterNodeAccess(Node<K,V> e)

先看 afterNodeAccess(Node<K,V> e) 方法，如果迭代顺序accessOrder 为true，代表LinkedHashMap 的双向链表需要每次在put/get操作 之后 将 put/get 的Node节点放在LinkedHashMap双向链表 的 末尾，这样LRU算法起作用的时候，删除不常用的节点，从双向链表头节点开始删除，最近使用（put/get操作）的节点，则在双向链表的尾结点，最后才会被删除，符合算法使用。（注：LinkedHashMap双向链表默认不会删除，只是把最近常用的节点放在 双向链表的最后）

/**
 * 若迭代顺序为true，且指定参数节点e不是尾结点，把指定参数节点e移到末尾
 */
void afterNodeAccess(Node<K,V> e) { // move node to last
    LinkedHashMap.Entry<K,V> last;
    //若迭代顺序为true，且指定参数节点e不是尾结点
    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;
    }
}

(2) afterNodeInsertion(boolean evict)

再看 afterNodeInsertion(boolean evict) 方法：

 /**
 * 可能把头节点删除
 */
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);
    }
}


/**
 * 如果map应该删除头节点，返回true
 *
 * 这个方法在被put和putAll方法被调用，当向map中插入一个新的entry时被执行。
 * 这个方法提供了当一个新的entry被添加到linkedHashMap中，删除头节点的机会。
 * 这个方法是很有用的，可以通过删除头节点来减少内存消耗，避免溢出。
 *
 * 简单的例子：这个方法的重写将map的最大值设为100，到100时，
 *             每次增一个entry，就删除一次头节点。
 *
 *     private static final int MAX_ENTRIES = 100;
 *     protected boolean removeEldestEntry(Map.Entry eldest) {
 *        //当map大小大于100时，返回true。意为允许删除头节点
 *        return size() > MAX_ENTRIES;
 *     }
 *
 * 这个方法一般不会直接修改map，而是通过返回true或者false来控制是否修改map。
 * 这个方法仅仅返回false，这样头节点就永远都不会被删除了。
 *
 * @param    eldest 头节点
 * @return   如果map应该删除头节点就返回true，否则返回false
 */
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
    return false;
}

evict，驱逐的意思。
（1） 如果evict为true，且头节点不为空，且确定移除最老的元素，那么就调用HashMap.removeNode()把头节点移除（这里的头节点是双向链表的头节点，而不是某个桶中的第一个元素）；
（2） HashMap.removeNode()从HashMap中把这个节点移除之后，会调用afterNodeRemoval()方法；
（3） afterNodeRemoval()方法在LinkedHashMap中也有实现，用来在移除元素后修改双向链表，见下文；
（4） 默认removeEldestEntry()方法返回false，也就是不删除元素。

removeEldestEntry方法的实现，发现永远返回false。
这意味着afterNodeInsertion这个方法什么都做不了。那这个方法有什么用？
如果重写removeEldestEntry方法，就能定义是否删除的规则，afterNodeInsertion就有用了。
可以自己写个demo使用 LinkedHashMap实现LRU算法：

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


public class LRUTest {
    public static void main(String[] args) {
        LRU<Integer, Integer>  lru = new LRU<>(4, 0.75f);
        lru.put(1, 1);
        lru.put(2, 2);
        lru.put(3, 3);
        lru.put(4, 4);
        lru.put(5, 5);
        lru.put(6, 6);
        // 输出 lru: {3=3, 4=4, 5=5, 6=6}
        System.out.println("lru: "+lru);
        lru.get(4);
        lru.put(3, 2333);
        // 输出 lru: {5=5, 6=6, 4=4, 3=2333}
        // 可以看到最旧的元素被删除了
        // 且最近访问的3被移到了后面
        System.out.println("lru: "+lru);
    }

}

class LRU<K, V> extends LinkedHashMap<K, V> {

    // 保存缓存的容量
    private int capacity;

    public LRU(int capacity, float loadFactor) {
        super(capacity, loadFactor, true);
        this.capacity = capacity;
    }

    /**
     * 重写removeEldestEntry()方法设置何时移除旧元素
     * @param eldest
     * @return
     */
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        // 当元素个数大于了缓存的容量, 就移除元素
        return size() > this.capacity;
    }
}

(3) afterNodeRemoval(Node<K,V> e)

在节点被删除之后调用的方法。
经典的把节点从双向链表中删除的方法。

void afterNodeRemoval(Node<K,V> e) { // unlink
    LinkedHashMap.Entry<K,V> p =
            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
    // 把节点p从双向链表中删除。
    p.before = p.after = null;
    if (b == null)
        head = a;
    else
        b.after = a;
    if (a == null)
        tail = b;
    else
        a.before = b;
}

4.get(Object key)方法

获取元素。

/**
 * 返回指定的key对应的entry的value，如果entry为null或者value为null，则返回null
 *
 * @see #put(Object, Object)
 */
public V get(Object key) {
    Node<K,V> e;
    //如果key对应的entry为null，返回null
    if ((e = getNode(hash(key), key)) == null)
        return null;
    //如果迭代顺序为按访问顺序迭代
    if (accessOrder)
        //将e插入双向链表末尾
        afterNodeAccess(e);
    //返回value
    return e.value;
}

如果查找到了元素，且accessOrder为true，则调用afterNodeAccess()方法把访问的节点移到双向链表的末尾。

5. 其余重写HashMap的方法

reinitialize()


//将linkedHashMap重置到初始化的默认状态
void reinitialize() {
    //重置哈希表
    super.reinitialize();
    //重置双向循环链表
    head = tail = null;
}

newNode( int hash, K key, V value, Node<K,V> e)

/**
 * 创建一个普通entry，将entry插入到双向循环链表的末尾,最后返回entry
 */
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
    //创建一个entry
    LinkedHashMap.Entry<K,V> p =
        new LinkedHashMap.Entry<K,V>(hash, key, value, e);
    //将entry插入到双向循环链表的末尾
    linkNodeLast(p);
    //返回entry
    return p;
}

replacementNode( Node<K,V> p, Node<K,V> next)

/**
 * 替换普通节点
 */
Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
    LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
    LinkedHashMap.Entry<K,V> t =
        new LinkedHashMap.Entry<K,V>(q.hash, q.key, q.value, next);
    transferLinks(q, t);
    return t;
}

newTreeNode( int hash, K key, V value, Node<K,V> next)

/**
 * 创建一个树的entry，将entry插入到双向循环链表的末尾,最后返回entry
 */
TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
    TreeNode<K,V> p = new TreeNode<K,V>(hash, key, value, next);
    linkNodeLast(p);
    return p;
}

replacementTreeNode( Node<K,V> p, Node<K,V> next)

/**
 * 替换树节点
 */
TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
    LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
    TreeNode<K,V> t = new TreeNode<K,V>(q.hash, q.key, q.value, next);
    transferLinks(q, t);
    return t;
}

四、总结

HashMap与LinkedHashMap比较

不同点：
HashMap数据结构是数组+链表+红黑树，数据节点是无序的
LinkedHashMap数据结构是数组+链表+红黑树+双向列表，数据节点是有序的
相同点：
都是基于哈希表的实现。
存储的是键值对映射。
都继承了AbstractMap，实现了Map、Cloneable、Serializable。
它们的构造函数都一样。
默认的容量大小是16，默认的加载因子是0.75。
都允许key和value为null。
都是线程不安全的。

五、参考

Java 8 容器源码-LinkedHashMap：http://cmsblogs.com/?p=3965
Map 综述（二）：彻头彻尾理解 LinkedHashMap：https://blog.csdn.net/justloveyou_/article/details/71713781

nowseeme
关注
专栏目录
LinkedHashMap详解
每天进步一点点的专栏
03-28 977
LinkedHashMap的一份简单理解
CHAMPION8888的博客
08-13 248
/ 今日科技快讯 / 近日，台湾地区媒体《经济日报》转引《日经亚洲评论》报道称，自去年起，已有100多位原台积电工程师和经理人员被挖角到中国大陆，从事芯片研发制造项目。对此台积电表示，员工是台积电最重要的资产，公司近年的年度离职率一直在5%以下；公司将继续致力留住人才、培育人才，提供员工具挑战性且正面的工作环境与长期职涯发展。 / 前言 / 这篇文章的内容包括LinkedHashMap 常用api的源码解析以及利用 LinkedHashMap来实现LRUCache算法。 说明： Linked
Map之LinkedHashMap源码实现
瘦子没有夏天
10-23 2087
一、引言 1.回顾 1.1 HashMap的是怎么保证添加的元素的索引的（也就是说哈希桶是如何分布的）？ 首先通过hash()方法:实现高位和低位进行充分位运算；然后通过 “table的长度” &amp;amp;amp; “hash值”，计算得出其bucket值。 1.2 HashMap的扩容的流程是怎么样的？ 把resize()的各种情况梳理一遍。值得注意的是：HashMap的的初始化操作也移到了resi...
LinkedHashMap 的核心就 2 点，搞清楚，也就掌握了
wanghao112956的博客
09-16 201
HashMap 有一个不足之处就是在迭代元素时与插入顺序不一致。而大多数人都喜欢按顺序做某些事情，所以，LinkedHashMap 就是针对这一点对 HashMap 进行扩展，主要新增了**「两种迭代方式」**： 按插入顺序 - 保证迭代元素的顺序与插入顺序一致 按访问顺序 - 一种特殊的迭代顺序，从最近最少访问到最多访问的元素访问顺序，非常适合构建 LRU 缓存 LinkedHashMap 的...
LinkedHashMap源码解析(一)
alvinhuai的专栏
10-13 2372
目录 简单概念 源码 简单概念        上面一篇博客分析了Lrucache的实现原理，我们知道他是通过自己实现同步，然后利用LinkedHashMap来实现的Lru功能。这篇文章就分析一下LinkedHashMap,首先说说它的一些基本的概念（基于jdk1.8）。         1 首先它是一个关联数组，哈希表。他不是线程安全的，key和value可以为空，这也是与hash...
java HashMap,TreeMap与LinkedHashMap的详解
09-01
在Java编程语言中，`HashMap`、`TreeMap`和`LinkedHashMap`都是`java.util.Map`接口的实现，它们提供了不同的数据存储和访问策略。本文将深入探讨这三种数据结构的特点、工作原理以及适用场景。 1. **HashMap** `...
linkedhashmap
06-26
持久化 LinkedHashMap Java LinkedHashMap 的 Haskell 实现。 底层 HashMap 基于 Data.HashMap.Strict。 两种不同的实现基于 Data.Sequence 和 Data.IntMap.Strict 来保持键的插入顺序。 标准报告： :
LinkedHashMapHelper:将LinkedHashMap转换为json，反之亦然
05-08
将LinkedHashMap转换为json，反之亦然 如何使用 LinkedHashMap requestData = new LinkedHashMap（）; LinkedHashMap auth =新的LinkedHashMap（）; auth.put（“ ServiceName”，“ Login”）; auth.put（“ ...
Java集合框架源码分析之LinkedHashMap详解
08-29
Java集合框架源码分析之LinkedHashMap详解 Java集合框架中的LinkedHashMap是HashMap的子类，它继承了HashMap的存储结构，但引入了一个双向链表的头结点，将所有put到LinkedHashMap的节点连接成一个双向循环链表，...
TreeMap删节点代码逻辑
qq_41030504的博客
05-15 162
private void deleteEntry(Entry<K,V> p) { modCount++; size--; // If strictly internal, copy successor's element to p and then make p // point to successor. //有两个子节点，找后继节点替换为待删节点 if (p.left != null &
红黑树完全解析(基于TreeMap)
gin_yz的博客
03-09 426
红黑树的例子 在线例子网址 https://www.cs.usfca.edu/~galles/visualization/RedBlack.html 内部节点及类定义 Get/Set方法省略 static class RBNode<K extends Comparable<K>, V> { private RBNode parent; private RBNode left; private RBNode right; private boolean color;
Java提高篇（二七）-----TreeMap
weixin_30580943的博客
05-23 2039
原文出自：http://cmsblogs.com/?p=1013。尊重作者的成果，转载请注明出处！ 个人站点：http://cmsblogs.com------------------------------------------------------------------------------------------------------------...
java treemap 遍历删除_Java 遍历Map时 删除元素
weixin_33604071的博客
03-02 1190
package net.nie.test;import java.util.HashMap;import java.util.Iterator;import java.util.Map;public class HashMapTest {private static Map map=new HashMap();/** 1.HashMap 类映射不保证顺序；某些映射可明确保证其顺序: TreeMa...
【Java集合类】 LinkedHashMap(有序的map)获取第一个元素和最后一个元素
热门推荐
hizhangyuping的博客
08-07 3万+
【Java集合类】 LinkedHashMap获取第一个元素和最后一个元素 获取LinkedHashMap中的头部元素（最早添加的元素）： 时间复杂度O(1) public &amp;amp;lt;K, V&amp;amp;gt; Entry&amp;amp;lt;K, V&amp;amp;gt; getHe...
HashMap和有序LinkedHashMap实现对比
井底之蛙
07-05 2万+
LinkedHashMap：LinkedHashMap简单来说是一个有序的HashMap，其是HashMap的子类，HashMap是无序的。接下来我们通过对比分析HashMap和LinkedHashMap来了解一下LinkedHashMap是如何实现有序的。首先HashMap及子类LinkedHashMap都提供了一个数组。 Node[] table  不同key的hash值是分布在这个数组中的
java8 TreeMap红黑树节点删除源码解析
菜鸟进阶之路
01-27 1286
目录 一、红黑树的规则 二、红黑树节点删除整体分析 三、红黑树节点删除具体情形分析 四、TreeMap删除节点源码解析 红黑树添加节点的平衡操作相对简单，具体分析参考java8 TreeMap接口实现源码解析，红黑树节点删除需要考虑的情形和翻转动作更复杂。综合各博客大神对该问题的分析，以TreeMap中红黑树节点删除相关代码为例，记录下自己对该问题的分析和理解，欢迎指正。 ...
TreeMap全面解析（包含红黑树插入删除）
洛豳枭薰
06-24 918
红黑树 1、规则 1、每个节点都只能是红色或者黑色 2、根节点是黑色 3、每个叶节点（NIL节点，空节点）是黑色的。 4、如果一个结点是红的，则它两个子节点都是黑的。也就是说在一条路径上不能出现相邻的两个红色结点。 5、从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。 2、插入原则 1、插入节点总是红色 2、插入节点父节点为黑色，则不影响 3、插入节点父节点为红色，需要左右旋转调整 ...
LinkedHashMap 详解
Hinbo的博客
12-10 1640
一、概述 概括的说，LinkedHashMap 是一个关联数组、哈希表，它是线程不安全的，允许key为null,value为null。 它继承自HashMap，实现了Map&amp;lt;K,V&amp;gt;接口。其内部还维护了一个双向链表，在每次插入数据，或者访问、修改数据时，会增加节点、或调整链表的节点顺序。以决定迭代时输出的顺序。 默认情况，遍历时的顺序是按照插入节点的顺序。这也是其与 HashMap 最...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值