Java中HashMap底层实现原理(JDK1.8)源码分析

最新推荐文章于 2025-03-19 11:18:17 发布
最新推荐文章于 2025-03-19 11:18:17 发布
阅读量4k 收藏 18
点赞数 5
分类专栏： JAVA 文章标签： HashMap

这几天学习了HashMap的底层实现,但是发现好几个版本的，代码不一，而且看了Android包的HashMap和JDK中的HashMap的也不是一样，原来他们没有指定JDK版本，很多文章都是旧版本JDK1.6.JDK1.7的。现在我来分析一哈最新的JDK1.8的HashMap及性能优化。


在JDK1.6，JDK1.7中，HashMap采用位桶+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用位桶+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。


简单说下HashMap的实现原理：

首先有一个每个元素都是链表（可能表述不准确）的数组，当添加一个元素（key-value）时，就首先计算元素key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了，这时就添加到同一hash值的元素的后面，他们在数组的同一位置，但是形成了链表，同一各链表上的Hash值是相同的，所以说数组存放的是链表。而当链表长度太长时，链表就转换为红黑树，这样大大提高了查找的效率。

     当链表数组的容量超过初始容量的0.75时，再散列将链表数组扩大2倍，把原链表数组的搬移到新的数组中

即HashMap的原理图是：

一，JDK1.8中的涉及到的数据结构

1，位桶数组

[java]  view plain  copy
 print ?
  1. transient Node<k,v>[] table;//存储（位桶）的数组</k,v>  
2，数组元素Node<K,V>实现了Entry接口

[java]  view plain  copy
 print ?
  1. //Node是单向链表，它实现了Map.Entry接口  
  2. static class Node<k,v> implements Map.Entry<k,v> {  
  3.     final int hash;  
  4.     final K key;  
  5.     V value;  
  6.     Node<k,v> next;  
  7.     //构造函数Hash值 键 值 下一个节点  
  8.     Node(int hash, K key, V value, Node<k,v> next) {  
  9.         this.hash = hash;  
  10.         this.key = key;  
  11.         this.value = value;  
  12.         this.next = next;  
  13.     }  
  14.    
  15.     public final K getKey()        { return key; }  
  16.     public final V getValue()      { return value; }  
  17.     public final String toString() { return key + = + value; }  
  18.    
  19.     public final int hashCode() {  
  20.         return Objects.hashCode(key) ^ Objects.hashCode(value);  
  21.     }  
  22.    
  23.     public final V setValue(V newValue) {  
  24.         V oldValue = value;  
  25.         value = newValue;  
  26.         return oldValue;  
  27.     }  
  28.     //判断两个node是否相等,若key和value都相等，返回true。可以与自身比较为true  
  29.     public final boolean equals(Object o) {  
  30.         if (o == this)  
  31.             return true;  
  32.         if (o instanceof Map.Entry) {  
  33.             Map.Entry<!--?,?--> e = (Map.Entry<!--?,?-->)o;  
  34.             if (Objects.equals(key, e.getKey()) &&  
  35.                 Objects.equals(value, e.getValue()))  
  36.                 return true;  
  37.         }  
  38.         return false;  
  39.     }  
3，红黑树

[java]  view plain  copy
 print ?
  1. //红黑树  
  2. static final class TreeNode<k,v> extends LinkedHashMap.Entry<k,v> {  
  3.     TreeNode<k,v> parent;  // 父节点  
  4.     TreeNode<k,v> left; //左子树  
  5.     TreeNode<k,v> right;//右子树  
  6.     TreeNode<k,v> prev;    // needed to unlink next upon deletion  
  7.     boolean red;    //颜色属性  
  8.     TreeNode(int hash, K key, V val, Node<k,v> next) {  
  9.         super(hash, key, val, next);  
  10.     }  
  11.    
  12.     //返回当前节点的根节点  
  13.     final TreeNode<k,v> root() {  
  14.         for (TreeNode<k,v> r = this, p;;) {  
  15.             if ((p = r.parent) == null)  
  16.                 return r;  
  17.             r = p;  
  18.         }  
  19.     }  

二，源码中的数据域

加载因子（默认0.75）：为什么需要使用加载因子，为什么需要扩容呢？因为如果填充比很大，说明利用的空间很多，如果一直不进行扩容的话，链表就会越来越长，这样查找的效率很低，因为链表的长度很大（当然最新版本使用了红黑树后会改进很多），扩容之后，将原来链表数组的每一个链表分成奇偶两个子链表分别挂在新链表数组的散列位置，这样就减少了每个链表的长度，增加查找效率

HashMap本来是以空间换时间，所以填充比没必要太大。但是填充比太小又会导致空间浪费。如果关注内存，填充比可以稍大，如果主要关注查找性能，填充比可以稍小。

[java]  view plain  copy
 print ?
  1. public class HashMap<k,v> extends AbstractMap<k,v> implements Map<k,v>, Cloneable, Serializable {  
  2.     private static final long serialVersionUID = 362498820763181265L;  
  3.     static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16  
  4.     static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量  
  5.     static final float DEFAULT_LOAD_FACTOR = 0.75f;//填充比  
  6.     //当add一个元素到某个位桶，其链表长度达到8时将链表转换为红黑树  
  7.     static final int TREEIFY_THRESHOLD = 8;  
  8.     static final int UNTREEIFY_THRESHOLD = 6;  
  9.     static final int MIN_TREEIFY_CAPACITY = 64;  
  10.     transient Node<k,v>[] table;//存储元素的数组  
  11.     transient Set<map.entry<k,v>> entrySet;  
  12.     transient int size;//存放元素的个数  
  13.     transient int modCount;//被修改的次数fast-fail机制  
  14.     int threshold;//临界值 当实际大小(容量*填充比)超过临界值时，会进行扩容   
  15.     final float loadFactor;//填充比（......后面略）  
三，HashMap的构造函数

HashMap的构造方法有4种，主要涉及到的参数有，指定初始容量，指定填充比和用来初始化的Map

[java]  view plain  copy
 print ?
  1. //构造函数1  
  2. public HashMap(int initialCapacity, float loadFactor) {  
  3.     //指定的初始容量非负  
  4.     if (initialCapacity < 0)  
  5.         throw new IllegalArgumentException(Illegal initial capacity:  +  
  6.                                            initialCapacity);  
  7.     //如果指定的初始容量大于最大容量,置为最大容量  
  8.     if (initialCapacity > MAXIMUM_CAPACITY)  
  9.         initialCapacity = MAXIMUM_CAPACITY;  
  10.     //填充比为正  
  11.     if (loadFactor <= 0 || Float.isNaN(loadFactor))  
  12.         throw new IllegalArgumentException(Illegal load factor:  +  
  13.                                            loadFactor);  
  14.     this.loadFactor = loadFactor;  
  15.     this.threshold = tableSizeFor(initialCapacity);//新的扩容临界值  
  16. }  
  17.    
  18. //构造函数2  
  19. public HashMap(int initialCapacity) {  
  20.     this(initialCapacity, DEFAULT_LOAD_FACTOR);  
  21. }  
  22.    
  23. //构造函数3  
  24. public HashMap() {  
  25.     this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted  
  26. }  
  27.    
  28. //构造函数4用m的元素初始化散列映射  
  29. public HashMap(Map<!--? extends K, ? extends V--> m) {  
  30.     this.loadFactor = DEFAULT_LOAD_FACTOR;  
  31.     putMapEntries(m, false);  
  32. }  
四，HashMap的存取机制

1，HashMap如何getValue值，看源码

[java]  view plain  copy
 print ?
  1. public V get(Object key) {  
  2.         Node<K,V> e;  
  3.         return (e = getNode(hash(key), key)) == null ? null : e.value;  
  4.     }  
  5.       /** 
  6.      * Implements Map.get and related methods 
  7.      * 
  8.      * @param hash hash for key 
  9.      * @param key the key 
  10.      * @return the node, or null if none 
  11.      */  
  12.     final Node<K,V> getNode(int hash, Object key) {  
  13.         Node<K,V>[] tab;//Entry对象数组  
  14.     Node<K,V> first,e; //在tab数组中经过散列的第一个位置  
  15.     int n;  
  16.     K k;  
  17.     /*找到插入的第一个Node，方法是hash值和n-1相与，tab[(n - 1) & hash]*/  
  18.     //也就是说在一条链上的hash值相同的  
  19.         if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) {  
  20.     /*检查第一个Node是不是要找的Node*/  
  21.             if (first.hash == hash && // always check first node  
  22.                 ((k = first.key) == key || (key != null && key.equals(k))))//判断条件是hash值要相同，key值要相同  
  23.                 return first;  
  24.       /*检查first后面的node*/  
  25.             if ((e = first.next) != null) {  
  26.                 if (first instanceof TreeNode)  
  27.                     return ((TreeNode<K,V>)first).getTreeNode(hash, key);  
  28.                 /*遍历后面的链表，找到key值和hash值都相同的Node*/  
  29.                 do {  
  30.                     if (e.hash == hash &&  
  31.                         ((k = e.key) == key || (key != null && key.equals(k))))  
  32.                         return e;  
  33.                 } while ((e = e.next) != null);  
  34.             }  
  35.         }  
  36.         return null;  
  37.     }  
get(key)方法时获取key的hash值，计算hash&(n-1)得到在链表数组中的位置first=tab[hash&(n-1)],先判断first的key是否与参数key相等，不等就遍历后面的链表找到相同的key值返回对应的Value值即可

2，HashMap如何put(key，value);看源码

[java]  view plain  copy
 print ?
  1. public V put(K key, V value) {  
  2.         return putVal(hash(key), key, value, false, true);  
  3.     }  
  4.      /** 
  5.      * Implements Map.put and related methods 
  6.      * 
  7.      * @param hash hash for key 
  8.      * @param key the key 
  9.      * @param value the value to put 
  10.      * @param onlyIfAbsent if true, don't change existing value 
  11.      * @param evict if false, the table is in creation mode. 
  12.      * @return previous value, or null if none 
  13.      */  
  14. final V putVal(int hash, K key, V value, boolean onlyIfAbsent,  
  15.                    boolean evict) {  
  16.         Node<K,V>[] tab;   
  17.     Node<K,V> p;   
  18.     int n, i;  
  19.         if ((tab = table) == null || (n = tab.length) == 0)  
  20.             n = (tab = resize()).length;  
  21.     /*如果table的在（n-1）&hash的值是空，就新建一个节点插入在该位置*/  
  22.         if ((p = tab[i = (n - 1) & hash]) == null)  
  23.             tab[i] = newNode(hash, key, value, null);  
  24.     /*表示有冲突,开始处理冲突*/  
  25.         else {  
  26.             Node<K,V> e;   
  27.         K k;  
  28.     /*检查第一个Node，p是不是要找的值*/  
  29.             if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))  
  30.                 e = p;  
  31.             else if (p instanceof TreeNode)  
  32.                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);  
  33.             else {  
  34.                 for (int binCount = 0; ; ++binCount) {  
  35.         /*指针为空就挂在后面*/  
  36.                     if ((e = p.next) == null) {  
  37.                         p.next = newNode(hash, key, value, null);  
  38.                //如果冲突的节点数已经达到8个，看是否需要改变冲突节点的存储结构，　　　　　　　　　　　　　  
  39. 　　　　　　　　　　　　//treeifyBin首先判断当前hashMap的长度，如果不足64，只进行  
  40.                         //resize，扩容table，如果达到64，那么将冲突的存储结构为红黑树  
  41.                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st  
  42.                             treeifyBin(tab, hash);  
  43.                         break;  
  44.                     }  
  45.         /*如果有相同的key值就结束遍历*/  
  46.                     if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))  
  47.                         break;  
  48.                     p = e;  
  49.                 }  
  50.             }  
  51.     /*就是链表上有相同的key值*/  
  52.             if (e != null) { // existing mapping for key，就是key的Value存在  
  53.                 V oldValue = e.value;  
  54.                 if (!onlyIfAbsent || oldValue == null)  
  55.                     e.value = value;  
  56.                 afterNodeAccess(e);  
  57.                 return oldValue;//返回存在的Value值  
  58.             }  
  59.         }  
  60.         ++modCount;  
  61.      /*如果当前大小大于门限，门限原本是初始容量*0.75*/  
  62.         if (++size > threshold)  
  63.             resize();//扩容两倍  
  64.         afterNodeInsertion(evict);  
  65.         return null;  
  66.     }  
下面简单说下添加键值对put(key,value)的过程：
1，判断键值对数组tab[]是否为空或为null，否则以默认大小resize()；
2，根据键值key计算hash值得到插入的数组索引i，如果tab[i]==null，直接新建节点添加，否则转入3
3，判断当前数组中处理hash冲突的方式为链表还是红黑树(check第一个节点类型即可),分别处理

五，HasMap的扩容机制resize();

构造hash表时，如果不指明初始大小，默认大小为16（即Node数组大小16），如果Node[]数组中的元素达到（填充比*Node.length）重新调整HashMap大小 变为原来2倍大小,扩容很耗时

[java]  view plain  copy
 print ?
  1.  /** 
  2.     * Initializes or doubles table size.  If null, allocates in 
  3.     * accord with initial capacity target held in field threshold. 
  4.     * Otherwise, because we are using power-of-two expansion, the 
  5.     * elements from each bin must either stay at same index, or move 
  6.     * with a power of two offset in the new table. 
  7.     * 
  8.     * @return the table 
  9.     */  
  10.    final Node<K,V>[] resize() {  
  11.        Node<K,V>[] oldTab = table;  
  12.        int oldCap = (oldTab == null) ? 0 : oldTab.length;  
  13.        int oldThr = threshold;  
  14.        int newCap, newThr = 0;  
  15.       
  16. /*如果旧表的长度不是空*/  
  17.        if (oldCap > 0) {  
  18.            if (oldCap >= MAXIMUM_CAPACITY) {  
  19.                threshold = Integer.MAX_VALUE;  
  20.                return oldTab;  
  21.            }  
  22. /*把新表的长度设置为旧表长度的两倍，newCap=2*oldCap*/  
  23.            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&  
  24.                     oldCap >= DEFAULT_INITIAL_CAPACITY)  
  25.       /*把新表的门限设置为旧表门限的两倍，newThr=oldThr*2*/  
  26.                newThr = oldThr << 1; // double threshold  
  27.        }  
  28.     /*如果旧表的长度的是0，就是说第一次初始化表*/  
  29.        else if (oldThr > 0) // initial capacity was placed in threshold  
  30.            newCap = oldThr;  
  31.        else {               // zero initial threshold signifies using defaults  
  32.            newCap = DEFAULT_INITIAL_CAPACITY;  
  33.            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);  
  34.        }  
  35.       
  36.       
  37.       
  38.        if (newThr == 0) {  
  39.            float ft = (float)newCap * loadFactor;//新表长度乘以加载因子  
  40.            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?  
  41.                      (int)ft : Integer.MAX_VALUE);  
  42.        }  
  43.        threshold = newThr;  
  44.        @SuppressWarnings({"rawtypes","unchecked"})  
  45. /*下面开始构造新表，初始化表中的数据*/  
  46.        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];  
  47.        table = newTab;//把新表赋值给table  
  48.        if (oldTab != null) {//原表不是空要把原表中数据移动到新表中      
  49.            /*遍历原来的旧表*/        
  50.            for (int j = 0; j < oldCap; ++j) {  
  51.                Node<K,V> e;  
  52.                if ((e = oldTab[j]) != null) {  
  53.                    oldTab[j] = null;  
  54.                    if (e.next == null)//说明这个node没有链表直接放在新表的e.hash & (newCap - 1)位置  
  55.                        newTab[e.hash & (newCap - 1)] = e;  
  56.                    else if (e instanceof TreeNode)  
  57.                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);  
  58. /*如果e后边有链表,到这里表示e后面带着个单链表，需要遍历单链表，将每个结点重*/  
  59.                    else { // preserve order保证顺序  
  60.                 新计算在新表的位置，并进行搬运  
  61.                        Node<K,V> loHead = null, loTail = null;  
  62.                        Node<K,V> hiHead = null, hiTail = null;  
  63.                        Node<K,V> next;  
  64.                       
  65.                        do {  
  66.                            next = e.next;//记录下一个结点  
  67.           //新表是旧表的两倍容量，实例上就把单链表拆分为两队，  
  68. 　　　　　　　　　　　　　//e.hash&oldCap为偶数一队，e.hash&oldCap为奇数一对  
  69.                            if ((e.hash & oldCap) == 0) {  
  70.                                if (loTail == null)  
  71.                                    loHead = e;  
  72.                                else  
  73.                                    loTail.next = e;  
  74.                                loTail = e;  
  75.                            }  
  76.                            else {  
  77.                                if (hiTail == null)  
  78.                                    hiHead = e;  
  79.                                else  
  80.                                    hiTail.next = e;  
  81.                                hiTail = e;  
  82.                            }  
  83.                        } while ((e = next) != null);  
  84.                       
  85.                        if (loTail != null) {//lo队不为null，放在新表原位置  
  86.                            loTail.next = null;  
  87.                            newTab[j] = loHead;  
  88.                        }  
  89.                        if (hiTail != null) {//hi队不为null，放在新表j+oldCap位置  
  90.                            hiTail.next = null;  
  91.                            newTab[j + oldCap] = hiHead;  
  92.                        }  
  93.                    }  
  94.                }  
  95.            }  
  96.        }  
  97.        return newTab;  
  98.    }  

六，JDK1.8使用红黑树的改进

在java jdk8中对HashMap的源码进行了优化，在jdk7中，HashMap处理“碰撞”的时候，都是采用链表来存储，当碰撞的结点很多时，查询时间是O（n）。
在jdk8中，HashMap处理“碰撞”增加了红黑树这种数据结构，当碰撞结点较少时，采用链表存储，当较大时（>8个），采用红黑树（特点是查询时间是O（logn））存储（有一个阀值控制，大于阀值(8个)，将链表存储转换成红黑树存储）


问题分析：

你可能还知道哈希碰撞会对hashMap的性能带来灾难性的影响。如果多个hashCode()的值落到同一个桶内的时候，这些值是存储到一个链表中的。最坏的情况下，所有的key都映射到同一个桶中，这样hashmap就退化成了一个链表——查找时间从O(1)到O(n)。


随着HashMap的大小的增长，get()方法的开销也越来越大。由于所有的记录都在同一个桶里的超长链表内，平均查询一条记录就需要遍历一半的列表。

JDK1.8HashMap的红黑树是这样解决的：

         如果某个桶中的记录过大的话（当前是TREEIFY_THRESHOLD = 8），HashMap会动态的使用一个专门的treemap实现来替换掉它。这样做的结果会更好，是O(logn)，而不是糟糕的O(n)。

        它是如何工作的？前面产生冲突的那些KEY对应的记录只是简单的追加到一个链表后面，这些记录只能通过遍历来进行查找。但是超过这个阈值后HashMap开始将列表升级成一个二叉树，使用哈希值作为树的分支变量，如果两个哈希值不等，但指向同一个桶的话，较大的那个会插入到右子树里。如果哈希值相等，HashMap希望key值最好是实现了Comparable接口的，这样它可以按照顺序来进行插入。这对HashMap的key来说并不是必须的，不过如果实现了当然最好。如果没有实现这个接口，在出现严重的哈希碰撞的时候，你就并别指望能获得性能提升了。


转自 http://blog.youkuaiyun.com/tuke_tuke/article/details/51588156


HashMap 底层 原理（JDK 1.8）
weihuiming
12-03 347
前言 原来看过1.7的hashMap底层，1.8更新后也稍微看了一下，没有进行仔细的总结，今天总结一下1.8底层的原理。本文只讨论1.8的底层原理。以下全文为1.8版本的 HashMap 数据结构 对于HashMap的数据结构，是老生常谈了，面试的时候经常会被问道。底层数据结构为数组+链表+红黑树，存储的是Node节点，红黑树是TreeNode。 进行put操作 在进行put...
JDK1.8HashMap底层实现原理
weixin_43145539的博客
05-27 4473
hashmap是我们开发中用的最常见的集合之一，但是我们是否有了解过他的底层呢？这篇文章我将带您了解一下hashmap的底层 位运算 在学习hashmap底层原理的时候，我们必须要掌握位运算，别问为什么，往下面看自然知晓 ...
(集合篇):HashMap的底层原理是什么？
最新发布
欢迎来到Mn_Hz的小博站
03-19 1514
本文关于hashMap的底层原理，已经源码分析，以及扩容机制是什么？添加元素的底层有什么怎么进行的，以及相关扩展部分
JDK7与JDK8中HashMap的实现
赶路人儿
08-31 775
1、JDK7中的HashMap HashMap底层维护一个数组，数组中的每一项都是一个Entry transient Entry[] table;我们向 HashMap 中所放置的对象实际上是存储在该数组当中；  而Map中的key，value则以Entry的形式存放在数组中 static class Entry implements Map.Entry { f
Jdk1.8中的HashMap实现原理
热门推荐
Richard_Jason的专栏
12-26 1万+
HashMap概述 HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 HashMap的数据结构 在Java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。HashMa
HashMap的源码，实现原理，JDK8中对HashMap做了怎样的优化
weixin_41719737的博客
10-31 2732
HashMap的源码，实现原理： HashMap的链表元素对应的是一个静态内部类Entry，Entry主要包含key，value，next三个元素 主要有put和get方法，put的原理是，通过hash%Entry.length计算index，此时记作Entry[index]=该元素。如果index相同 就是新入的元素放置到Entry[index]，原先的元素记作Entry[index].n...
HashMap 源码详细分析(JDK1.8)
windy杨树的博客
03-16 508
目录 1. 概述 本篇文章我们来聊聊大家日常开发中常用的一个集合类 -HashMap。HashMap 最早出现在 JDK 1.2中，底层基于散列算法实现。HashMap 允许 null 键和 null 值，在计算哈键的哈希值时，null 键哈希值为 0。HashMap 并不保证键值对的顺序，这意味着在进行某些操作后，键值对的顺序可能会发生变化。另外，需要注意的是，HashMap 是...
HashMap底层原理及hashmap扩容源码详细解读（JDK1.8）
efggfxfvhh的博客
08-22 1235
HashMap底层原理及hashmap扩容源码详细解读（JDK1.8）
JDK1.8之前与之后 HashMap底层实现原理的差别
qq_51901495的博客
08-12 1072
hashmap的概述 HashMap 基于哈希表的 Map 接口实现，是以 key-value 存储形式存在，即主要用来存放键值对。 HashMap 的实现不是同步的，这意味着它不是线程安全的。它的 key、value 都可以为 null，此外，HashMap中的映射不是有序的。 jdk1.8 之前 HashMap 由 数组 + 链表 组成，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突（两个对象调用的hashCode 方法计算的哈希值经哈希函数算出来的地址被别的元素占用）而存在的（“拉链法”
JDK1.8版本HashMap源码原理分析
HYM BLOG
10-27 1030
HashMap是一个KV的容器对象，也是日常在开发当中非常常用的对象，比如我们可能经常做一些内存缓存的时候，很多时候就选用HashMap这种KV的数据结构。在实现原理上，是基于哈希表的Map接口实现，是常用的java集合之一，非线程安全的。 HashMap可以存储null的key和value，但是null作为键值只能有一个，做为值的话，可以是多个。这和Map的键要保持唯一性并不冲突。 一、HashMap的类图结构 二、概念、原理概述 Jdk1.8之前的HashMap是由数组+链表作为底层数据结构实现的，数
HashMap底层原理（JDK1.8）
earlybird_xiong的博客
11-23 1080
HashMap是由数据+链表+红黑树的形式组成的。数组：是一块连续的存储空间，存储的每一个元素都有自己的下标。链表：每一个元素存储下一个元素的内存地址，链式存储，存储元素离散。HashMap底层的数据结构是hash散列表，结合了数组+链表两种数据结构。采用Node（继承自Entry）数组来存储key-value的键值对，一个Node对应一个键值对，Node类是一个单向链表的结构，通过next（Node类型）指针连接下一个Node节点(解决hash冲突问题)。
Java底层原理——HashMap底层原理（JDK1.8）
qq_58485138的博客
03-16 621
从1.7中可知HashMap是数组+链表的结构，HashMap在JDK1.8中加入了的实现，当链表长度大于8时，转换为红黑树的结构。java8中没有indexFor函数，而是直接使用table[index=(n-1)&hash]在JDK1.8中也使用了取代Entry的Node来实现Map.Entry接口Node是一个内部类，实现了Map.Entry接口，本质就是一个键值对。HashMap类中有一个非常重要的字段，就是Node[] table,即哈希桶数组，很明显它是一个Node的数组。
jdk1.8之HashMap底层原理
coffee_fighter的博客
11-18 335
通俗概括 可以通俗地理解HashMap是一个存储元素为链表的数组。首先，用户调用put（key，value）方法存储一对键值对的时候。会先调用key.hash()获取key的哈希值，通过这个哈希值确定这对键值对应该存储在数组中的位置，如果这个位置上已经存储有元素了，就说明发生了哈希冲突了。这时候就是通过将新的键值对放在旧的键值对后面，形成链表。如果链表过长的话，会装换成红黑树以便提高元素的查找效率。同时，hashmap的扩容因子是0.75，初始容量是16，就是当该hashmap中的元素总数大于 现容量x扩
Java的HashMap底层实现原理（jdk1.8）
Autter的博客
06-10 2325
标记：vivo 提前批大数据开发岗问到HashMap底层的实现原理，回答的很烂，所以作此知识点的补充，以后在遇到java 的这些高频知识点，争取能够流利的回答出来。 在jdk1.6 1.7中，HashMap 采用位 |桶（容量）+链表实现，即使采用了链表来解决冲突，同一Hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过 key 值查询的效率会很低。而在 jdk 1.8 中 HashMap 采用位桶 + 链表 + 红黑树 实现，当链表长度超过阈值**（8）*
剖析HashMap底层原理（JDK1.8）
zwz的学习之路
04-11 373
1.HashMap的底层数据结构？ 看源码： static class Node&lt;K,V&gt; implements Map.Entry&lt;K,V&gt; { final int hash; final K key; V value; //注意此处的Next Node&lt;K,V&gt; next; ...
HashMap 底层实现原理是什么？JDK8 做了哪些优化？
weixin_44741522的博客
11-11 280
第02讲：HashMap 底层实现原理是什么？JDK8 做了哪些优化？ HashMap 是使用频率最高的类型之一，同时也是面试经常被问到的问题之一，这是因为 HashMap 的知识点有很多，同时它又属于 Java 基础知识的一部分，因此在面试中经常被问到。 本课时的面试题是，HashMap 底层是如何实现的？在 JDK 1.8 中它都做了哪些优化？ 典型回答 在 JDK 1.7 中 HashMap 是以数组加链表的形式组成的，JDK 1.8 之后新增了红黑树的组成结构，当链表大于 8 并且容量大于 64 时
HashMap底层原理详解(JDK1.8)
一见的博客
08-05 301
HashMap的put方法脑图 ! 在这里插入图片描述 HashMap的resize方法脑图
由浅入深读懂HashMap底层原理（jdk版本1.8）
梵城专栏
08-01 466
1，HashMap的底层在jdk1.7的时候是数组，也就是我们说的hash桶和链表，而在1.8的时候，是数组， 链表|红黑树。就是说要么是链表，要么是红黑树。 2， HashMap类实现了Map接口，而在Map接口中，定义了内部接口类，Entry interface Entry&lt;K,V&gt; 而这个entry 类关注的其实就是K和V,也就是key和value。 3， Ha...
JDK1.8 HashMap详解：原理与源码分析
HashMap作为Java开发中常用的集合类，其底层实现是基于散列算法，特别是拉链式散列，它将数据存储在数组和链表（或在JDK1.8以后的红黑树）中，以实现快速的查找、插入和删除操作。 首先，HashMap支持null键和null值...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值