HashMap 学习(摘抄)

最新推荐文章于 2023-05-17 15:02:52 发布
最新推荐文章于 2023-05-17 15:02:52 发布
阅读量92 收藏
点赞数
分类专栏： 杂 文章标签： hashmap
原文链接：https://blog.csdn.net/login_sonata/article/details/76598675;https://www.cnblogs.com/ysocean/p/8711071.html#_label0
版权

HashMap 学习（摘抄）

原文查看：

HashMap是基于哈希表的Map接口的实现，允许使用null值和null键。HashMap是非线程安全的，也就是说在多个线程同时对HashMap中的某个元素进行增删改操作的时候，是不能保证数据的一致性的。
如果需要满足线程安全，可以用 Collections的synchronizedMap方法使HashMap具有线程安全的能力，或者使用ConcurrentHashMap。

遇到冲突时，HashMap 是采用的链地址法来解决，在 JDK1.7 中，HashMap 是由 数组+链表构成的。但是在 JDK1.8 中，HashMap 是由 数组+链表+红黑树构成，新增了红黑树作为底层数据结构，结构变得复杂了，但是效率也变的更高效。

HashMap 类

  • 首先该类实现了一个 Map 接口，该接口定义了一组键值对映射通用的操作。
  • JDK 还为我们提供了一个抽象类 AbstractMap ，该抽象类继承 Map 接口，所以如果我们不想实现所有的 Map 接口方法，就可以选择继承抽象类 AbstractMap 。
  • HashMap 集合还实现了 Cloneable 接口以及 Serializable 接口，分别用来进行对象克隆以及将对象进行序列化。
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

HashMap 内部类

Node 类

Node是HashMap的一个内部类，实现了Map.Entry接口，本质就是一个映射(键值对)。

    /**
     * Basic hash bin node, used for most entries.  (See below for
     * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
     */
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;  //  用来定位数组索引位置
        final K key;
        V value;
        Node<K,V> next;    //链表的下一个node

        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() { ...}
        public final V setValue(V newValue) { ... }
        public final boolean equals(Object o) {  ... }
    }

HashMap 字段属性

常量
//序列化和反序列化时，通过该字段进行版本一致性验证
private static final long serialVersionUID = 362498820763181265L;

//默认 HashMap 集合初始容量为16（必须是 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;

//当桶(bucket)上的结点数大于这个值时会转成红黑树(JDK1.8新增)
static final int TREEIFY_THRESHOLD = 8;

//当桶(bucket)上的节点数小于这个值时会转成链表(JDK1.8新增)
static final int UNTREEIFY_THRESHOLD = 6;

/**(JDK1.8新增)
  * 当集合中的容量大于这个值时，表中的桶才能进行树形化 ，否则桶内元素太多时会扩容，
  * 而不是树形化 为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD
  */
static final int MIN_TREEIFY_CAPACITY = 64;
变量
// 初始化使用，长度总是 2的幂 哈希桶数组
transient Node<K,V>[] table;

// 保存缓存的entrySet（）
transient Set<Map.Entry<K,V>> entrySet;

// 此映射中包含的键值映射的数量。（集合存储键值对的数量）
transient int size;

// 记录集合被修改的次数,主要用于迭代器中的快速失败 （? 没理解） 出现线程问题时，负责及时抛异常
transient int modCount;

// 调整大小的下一个大小值（容量*加载因子）。 capacity * loadFactor
int threshold;

// 散列表的加载因子。
final float loadFactor;
  • Node<K,V>[] table
    HashMap 是由数组+链表+红黑树组成，这里的数组就是 table 字段。哈希桶数组。
  • size
    集合中存放key-value 的实时对数。
  • loadFactor
    装载因子，是用来衡量 HashMap 满的程度，计算HashMap的实时装载因子的方法为：size/capacity，而不是占用桶的数量去除以capacity。capacity 是桶的数量，也就是 table 的长度length。
    默认的负载因子0.75 是对空间和时间效率的一个平衡选择。
    • 加载因子越大,填满的元素越多,好处是: 空间利用率高了,但: 冲突的机会加大了.链表长度会越来越长,查找效率降低。如果内存空间紧张而对时间效率要求不高，可以增加负载因子 loadFactor 的值，这个值可以大于1。
    • 加载因子越小,填满的元素越少,好处是: 冲突的机会减小,但: 空间浪费多了. 表中的数据将过于稀疏（很多空间还没用，就开始扩容了）。如果内存空间很多而又对时间效率要求很高，可以降低负载因子loadFactor 的值
  • modCount
    modCount字段主要用来记录HashMap内部结构发生变化的次数。内部结构发生变化指的是结构发生变化，例如put新键值对，但是某个key对应的value值被覆盖不属于结构变化。
  • threshold
    　计算公式：capacity * loadFactor。这个值是当前已占用数组长度的最大值。过这个数目就重新resize(扩容)，扩容后的 HashMap 容量是之前容量的两倍。

HashMap 构造函数

无参构造函数
// 默认构造函数，初始化加载因子loadFactor = 0.75
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
有参构造函数
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

/**
 * @param  initialCapacity 指定初始化容量
 * @param  loadFactor      加载因子 0.75
 * @throws IllegalArgumentException if the initial capacity is negative
 *         or the load factor is nonpositive
 */
public HashMap(int initialCapacity, float loadFactor) {

    //初始化容量不能小于 0 ，否则抛出异常
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);

    //如果初始化容量大于2的30次方，则初始化容量都为2的30次方
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;

    //如果加载因子小于0，或者加载因子是一个非数值，抛出异常
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " + loadFactor);

    this.loadFactor = loadFactor;
    this.threshold = tableSizeFor(initialCapacity);
}
  • tableSizeFor(int cap) 方法
    主要功能是返回一个比给定整数大且最接近的2的幂次方整数，如给定7，返回2的3次方8。
/**
 * Returns a power of two size for the given target capacity.
 */
static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

无符号右移和有符号右移

  • >>>: 无符号右移 (无论是正数还是负数，高位通通补0。)
  • >>: 有符号右移 （正数右移高位补0，负数右移高位补1。）
n |= n >>> 1 分解为：
    n1 = n >>> 1
    n = n | n1

假定cap也就是给定数的二进制形式为 00..01XXXXXXX ,(X代表可为0也可为1，X前面的1为从最高位开始第一个为1的那一位)

第一步: n |= n >>> 1
n 的二进制：00..01XXXXXXX
n >>> 1（向右移动一位，即n的原值除以2以后，获得的2进制）: 00..001XXXXXX
n 与 n >>> 1 做 |（位或运算符）或得到新 n： 00..011XXXXXX

第二步: n |= n >>> 2
n 的二进制： 00..011XXXXXX
n >>> 2: 00..00011XXXX
n 与 n >>> 2 做 |（位或运算符）或得到新 n：: 00..01111XXXX

这个算法不断的通过把第一个1开始后面的位变成1，本例由00..01XXXXXXX => 00..011111111,最后再返回n+1;

直观体验一下，打印流程：

public class Test {

    private static final int MAXIMUM_CAPACITY = 1 << 30;

    public static void main(String[] args) {
        System.out.println(MAXIMUM_CAPACITY);
        System.out.println( "返回值n: " + tableSizeFor(1256));
    }

    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        System.out.println("=n=");
        System.out.println(Integer.toBinaryString(n));
        System.out.println(n);
        n |= n >>> 1;
        System.out.println("=n |= n >>> 1=");
        System.out.println(Integer.toBinaryString(n));
        System.out.println(n);
        n |= n >>> 2;
        System.out.println("=n |= n >>> 2=");
        System.out.println(Integer.toBinaryString(n));
        System.out.println(n);
        n |= n >>> 4;
        System.out.println("=n |= n >>> 4=");
        System.out.println(Integer.toBinaryString(n));
        System.out.println(n);
        n |= n >>> 8;
        System.out.println("=n |= n >>> 8=");
        System.out.println(Integer.toBinaryString(n));
        System.out.println(n);
        n |= n >>> 16;
        System.out.println("=n |= n >>> 16=");
        System.out.println(Integer.toBinaryString(n));
        System.out.println(n);
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }
}

HashMap 方法

hash() 确定哈希桶数组索引位置
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

i = (table.length - 1) & hash;//这一步是在后面添加元素putVal()方法中进行位置的确定

主要分为三步：

1、取 hashCode 值： key.hashCode()

  • 这里点进去 Object 的 public native int hashCode();方法，调用本地方法。
  • 这里获取 hashCode() 方法的值是变量，但是我们知道，对于任意给定的对象，只要它的 hashCode() 返回值相同，那么程序调用 hash(Object key) 所计算得到的 hash码 值总是相同的。

2、高位参与运算：h>>>16
3、取模运算：(n-1) & hash

HashMap 使用的方法很巧妙，它通过 hash & (table.length -1)来得到该对象的保存位，前面说过 HashMap 底层数组的长度总是2的n次方，这是HashMap在速度上的优化。当 length 总是2的n次方时，hash & (length-1)运算等价于对 length 取模，也就是 hash%length，但是&比%具有更高的效率。 比如 n % 32 = n & (32 -1)

这也解释了为什么要保证数组的长度总是2的n次方。

再就是在 JDK1.8 中还有个高位参与运算，hashCode() 得到的是一个32位 int 类型的值，通过hashCode()的高16位 异或 低16位实现的：(h = k.hashCode()) ^ (h >>> 16)，主要是从速度、功效、质量来考虑的，这么做可以在数组table的length比较小的时候，也能保证考虑到高低Bit都参与到Hash的计算中，同时不会有太大的开销。
在这里插入图片描述

put() 添加元素
//hash(key)就是上面讲的hash方法，对其进行了第一步和第二步处理
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
/**
 *
 * @param hash 索引的位置
 * @param key  键
 * @param value  值
 * @param onlyIfAbsent true 表示不要更改现有值
 * @param evict false表示table处于创建模式
 * @return
 */
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为null或者长度为0，则进行初始化
     //resize()方法本来是用于扩容，由于初始化没有实际分配空间，这里用该方法进行空间分配，后面会详细讲解该方法
     if ((tab = table) == null || (n = tab.length) == 0)
         n = (tab = resize()).length;
     //注意：这里用到了前面讲解获得key的hash码的第三步，取模运算，下面的if-else分别是 tab[i] 为null和不为null
     if ((p = tab[i = (n - 1) & hash]) == null)
         tab[i] = newNode(hash, key, value, null);//tab[i] 为null，直接将新的key-value插入到计算的索引i位置
     else {//tab[i] 不为null，表示该位置已经有值了
         Node<K,V> e; K k;
         if (p.hash == hash &&
             ((k = p.key) == key || (key != null && key.equals(k))))
             e = p;//节点key已经有值了，直接用新值覆盖
         //该链是红黑树
         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);
                     //链表长度大于8，转换成红黑树
                     if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                         treeifyBin(tab, hash);
                     break;
                 }
                 //key已经存在直接覆盖value
                 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);    // 空的方法实现LinkedHashMap 会用到，LinkedHashMap 是继承的 HashMap，并且重写了该方法
             return oldValue;
         }
     }
     ++modCount;//用作修改和新增快速失败
     if (++size > threshold)//超过最大容量，进行扩容
         resize();
     afterNodeInsertion(evict);  // 空的方法实现LinkedHashMap 会用到，LinkedHashMap 是继承的 HashMap，并且重写了该方法
     return null;
}

if (++size > threshold)//超过最大容量，进行扩容
    resize();
    afterNodeInsertion(evict);
    return null;
}

只要是调用 put() 方法添加元素，那么就会调用 ++size (这里有个例外是插入重复 key 的键值对，不会调用，重复key元素不会影响size)

HashMap 是由数组+链表+红黑树（JDK1.8）组成，如果在添加元素时，发生冲突，会将冲突的数放在链表上，当链表长度超过8时，会自动转换成红黑树。

resize() 扩容
final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;//原数组如果为null，则长度赋值0
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {//如果原数组长度大于0
            if (oldCap >= MAXIMUM_CAPACITY) {//数组大小如果已经大于等于最大值(2^30)
                threshold = Integer.MAX_VALUE;//修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
                return oldTab;
            }
            //原数组长度大于等于初始化长度16，并且原数组长度扩大1倍也小于2^30次方
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // 阀值扩大1倍
        }
        else if (oldThr > 0) //旧阀值大于0，则将新容量直接等于就阀值
            newCap = oldThr;
        else {//阀值等于0，oldCap也等于0（集合未进行初始化）
            newCap = DEFAULT_INITIAL_CAPACITY;//数组长度初始化为16
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//阀值等于16*0.75=12
        }
        //计算新的阀值上限
        if (newThr == 0) {
            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) {
            //把每个bucket都移动到新的buckets中
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;//元数据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;
                            }
                            //原索引+oldCap
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        //原索引放到bucket里
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        //原索引+oldCap放到bucket里
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

n为table的长度，图（a）表示扩容前的key1和key2两种key确定索引位置的示例，图（b）表示扩容后key1和key2两种key确定索引位置的示例，其中hash1是key1对应的哈希与高位运算结果。
在这里插入图片描述

元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：
在这里插入图片描述

可以看看下图为16扩充为32的resize示意图：
在这里插入图片描述
JDK1.8使用的是2次幂的扩展(指长度扩为原来2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。
我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap（原数组的长度）”。

累了，把自己理解的内容整到一起。
稻草人0.0
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
马士兵老师HashMap学习笔记
02-28
马士兵老师HashMap学习笔记
HashMap_学习
03-29
这是一套PPT，讲述的内容是Java的JDK中内置的几种常用的集合框架工具类的知识，重点讲解HashMap，因为不让上传视频，就先传个PPT试试；
HashMap(常用)方法
Hningning的博客
07-22 1408
文章目录 Hashmap的存值： Hashmap的取值： Hashmap的判断为空 Hashmap判断是否含有key： Hashmap判断是否含有value： Hashmap删除这个key值下的value： Hashmap显示所有的value值： Hashmap的元素个数： Hashmap删除这个key值下的value： Hashmap显示所有的key和value： Hashmap添加另一个同一类型的map下的所有值： Hashmap删除这个key和valu
HashMap详解
热门推荐
java123456111的博客
03-09 5万+
一、HashMap集合简介 HashMap 基于哈希表的 Map 接口实现，是以 key-value 存储形式存在，即主要用来存放键值对。HashMap 的实现不是同步的，这意味着它不是线程安全的。它的 key、value 都可以为 null，此外，HashMap 中的映射不是有序的。 jdk1.8 之前 HashMap 由 数组 + 链表 组成，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突（两个对象调用的 hashCode 方法计算的哈希值经哈希函数算出来的地址被别的元素占用）而存
Java基础语法—HashMap（哈希表）
kuangd_1992的博客
12-02 2467
创建hashmap对象 HashMap<String,Integer> hashMap = new HashMap<>(); 添加键值对 如果key已经存在，则返回旧的value，并将新的value存到该key中，如果key不存在，返回null 1、put方法：覆盖原有的value hashMap.put(key,value); 2、putIfAbsent方法：不会覆盖原有的value。 hashMap.putIfAbsent(key,value); 该方法首先
HashMap常用方法总结
慢慢来，谁还没有一个努力的过程。
05-17 3348
9、containsValue(Object value)： 判断集合中是否包含指定值，包含返回 true，否则返回false。9、containsValue(Object value) 判断集合中是否包含指定值，包含返回 true，否则返回false。8、containsKey(Object key)： 判断集合中是否包含指定键，包含返回 true，否则返回false。2、get(Object key)： 返回指定键所映射的值，没有该key对应的值则返回 null。
Java 集合系列之 HashMap详细介绍(源码解析)和使用示例
fivehundredyearsago的博客
12-27 659
概要 这一章，我们对HashMap进行学习。 我们先对HashMap有个整体认识，然后再学习它的源码，最后再通过实例来学会使用HashMap。内容包括： 第1部分 HashMap介绍 第2部分 HashMap数据结构 第3部分 HashMap源码解析(基于JDK1.6.0_45)     第3.1部分 HashMap的“拉链法”相关内容     第3.2部分 HashMa
C语言实现hashMap
11-10
C语言实现hashMap，包含创建hashMap、插入hashMap、查找hashMap、删除hashMap，已经若干经典的hash函数。文章链接：https://blog.csdn.net/sxf1061700625/article/details/109594495
java中HashMap详解
07-04
HashMap是Java中非常常用的一种数据结构，它实现了Map接口，用于存储键值对。HashMap内部使用哈希表来实现，通过将键映射到哈希表中的一个位置来快速查找和插入元素。 HashMap的主要特点是： 非线程安全：如果多个...
JAVA中哈希表HashMap的深入学习
08-18
主要介绍了哈希表HashMap的深入学习,哈希表是一种非常重要的数据结构,许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，本文会对java集合框架中HashMap的实现原理进行讲解。感兴趣的话可以...
HashMap常用方法
芳草萋萋鹦鹉洲哦
04-12 215
结构代码： public static void main(String[] args) { HashMap<Integer,String> map=new HashMap<>(); //下面放方法 } 存值 put(key, value)： HashMap<Integer, String> map = new HashMap<>(); //向map中添加值(返回这个key以前的value,如果没有返回null)
Java中Map使用详解
訾博（ZiBo）的博客
11-24 4725
一、初识Map 1、初识Map 2、Map通用方法
HashMap的常见用法
qq_41571459的博客
10-03 4089
文章目录1、常用方法示例2、3种遍历方式3、定义的时候初始化4、getOrDefault(Object key, V defaultValue)5、putIfAbsent(K key, V value) 1、常用方法示例 Map<String,Integer> map=new HashMap<>();//Map父类 map.put("zhangsan", 10); map.put("lisa", 20); map.put("wangwu", 50);
Map<String, Object> paramMap = new HashMap<String, Object>();含义解释
ALEX__0805的专栏
05-27 1万+
1：你首先要明白Map是什么意思 Map得意思就是Key value对应得就比如以下： Map你只要得到Map里面得1 他对应得值就是 我 2：意思是你的Map对象的键是String类型的，而值因为被定义为最上层的java对象Object对象，而所有的下级对象都隶属于Object对象，所以可以传任何类型的值在里面，比如，你可以这样： paramMap .put("userid","lian
Java HashMap基础解读（二）
ITloser的博客
08-01 278
回顾 上一篇文章我们对HashMap的设计思路、存储值的方式、解决碰撞的方式、取值等角度进行了说明，不了解相关内容的请先阅读上一篇的内容。 本次我们主要理解2个问题 数据量过大时，HashMap的扩充方案。 当HashMap存储值时链表过长时，JDK1.8的优化方案。 HashMap的扩充 在引入扩充前我们需要对HashMap的容量进行初步的了解，控制HashMap的容量的因素主...
深入理解HashMap
皮皮的雅客
08-09 202
HashMap 在日常开发中使用频率很高，是Java程序员经常使用的用于映射(键值对)处理的数据类型。本文结合源码，深入分析HashMap的底层原理。 属性解析 存储结构(基于JDK1.8) HashMap是数组 + 链表 + 红黑树 实现的： 几个重要的属性解析 static final int DEFAULT_INITIAL_CAPAC...
HashMap
Mylily_123的博客
05-31 177
HashMap
Java进阶--深入解析hashmap
有图有真相
04-22 7032
HashMap原理先以一个简单的例子来理解hashmap的原理。在Java中先随机产生一个大小为20的数组如下：hash表的大小为7，将上面数组的元素，按mod 7分类如下图：将这些点插入到hashmap中（简单hashmap）后如下图：由上图可知： ① hashmap是用链地址法进行处理，多个key 对应于表中的一个索引位置的时候进行链地址处理，hashmap其实就是一个数组+链表的形式。②
hashmap内容读入hashmap
最新发布
11-21
根据提供的引用，可以了解到Map集合是一种键值对应的数据结构，而HashMap是Map集合的一种实现方式。在Java中，可以通过读取文件的方式将内容读入HashMap中。具体实现步骤如下： 1. 创建一个空的HashMap对象，用于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值