深度解析HashMap工作原理

于 2025-04-14 09:23:57 发布
阅读量1.3k 收藏 24
点赞数 31
分类专栏： Android系列教程 文章标签： 哈希算法 散列表 算法 android java 面试 HashMap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hai_qing_xu_kong/article/details/147202227
版权

一、引言

在 Java 编程中，HashMap 是一个极为常用且重要的数据结构，它属于 Java 集合框架的一部分，用于存储键值对。HashMap 以其高效的查找、插入和删除操作而闻名，广泛应用于各种 Java 程序中。本文将全方位、深入地剖析 HashMap 的原理，包含底层数据结构、核心属性、构造方法、常用操作的实现细节，还会结合代码示例帮助读者更好地理解。

二、HashMap 概述

2.1 定义与用途

HashMap 是 java.util 包下的一个类，实现了 Map 接口。它允许存储 null 键和 null 值，并且不保证元素的顺序。HashMap 的主要用途是存储键值对，通过键可以快速查找对应的值，适用于需要快速查找和存储数据的场景，例如缓存、数据映射等。

2.2 继承关系与实现接口

HashMap 的继承关系如下：

java.lang.Object
    └─ java.util.AbstractMap<K,V>
        └─ java.util.HashMap<K,V>

它实现了 Map<K,V>、Cloneable 和 java.io.Serializable 接口，具备克隆和序列化的能力。

import java.util.HashMap;
import java.util.Map;

public class HashMapOverview {
    public static void main(String[] args) {
        // 创建一个 HashMap 对象
        HashMap<String, Integer> hashMap = new HashMap<>();
        // 可以将其赋值给 Map 接口类型的变量
        Map<String, Integer> map = hashMap;
    }
}

三、底层数据结构：哈希表（数组 + 链表 + 红黑树）

3.1 哈希表的基本概念

哈希表是一种根据键（Key）直接访问内存存储位置的数据结构。它通过哈希函数将键映射到一个固定大小的数组中的某个位置，这个位置称为桶（Bucket）。当多个键映射到同一个桶时，就会发生哈希冲突。

3.2 Java 8 之前的实现（数组 + 链表）

在 Java 8 之前，HashMap 的底层数据结构是数组 + 链表。数组中的每个元素是一个链表的头节点，当发生哈希冲突时，新的键值对会以链表的形式添加到对应桶的链表中。查找元素时，先通过哈希函数找到对应的桶，然后遍历链表找到目标键值对。

3.3 Java 8 及之后的实现（数组 + 链表 + 红黑树）

Java 8 对 HashMap 进行了优化，当链表长度超过 8 且数组长度大于 64 时，链表会转换为红黑树。红黑树是一种自平衡的二叉搜索树，它的查找、插入和删除操作的时间复杂度为 O ( l o g n ) O(log n) O(logn)，可以提高在链表较长时的查找效率。当树中的节点数小于 6 时，红黑树会转换回链表。

3.4 节点结构

HashMap 中的节点有三种类型：Node、TreeNode 和 LinkedHashMap.Entry（用于 LinkedHashMap 扩展）。Node 是普通的链表节点，TreeNode 是红黑树节点。

// 普通链表节点
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;

    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }
    // 其他方法省略
}

// 红黑树节点
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
    TreeNode<K,V> parent;  // red-black tree links
    TreeNode<K,V> left;
    TreeNode<K,V> right;
    TreeNode<K,V> prev;    // needed to unlink next upon deletion
    boolean red;
    TreeNode(int hash, K key, V val, Node<K,V> next) {
        super(hash, key, val, next);
    }
    // 其他方法省略
}

四、核心属性

HashMap 有几个重要的核心属性，这些属性控制着 HashMap 的行为和性能：

// 存储数据的数组
transient Node<K,V>[] table;
// 键值对的数量
transient int size;
// 扩容阈值，当 size 达到 threshold 时，会进行扩容
int threshold;
// 负载因子，默认为 0.75
final float loadFactor;
// 修改次数，用于快速失败机制
transient int modCount;
  • table：存储键值对的数组，数组的每个元素是一个链表或红黑树的头节点。
  • size：表示 HashMap 中键值对的数量。
  • threshold：扩容阈值，计算公式为 threshold = capacity * loadFactor，当 size 超过 threshold 时，会进行扩容操作。
  • loadFactor：负载因子，默认值为 0.75，它决定了哈希表在多满时进行扩容。
  • modCount：记录 HashMap 的修改次数，用于快速失败机制，当在迭代过程中检测到 modCount 发生变化时，会抛出 ConcurrentModificationException。

五、构造方法

5.1 无参构造方法

public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

无参构造方法将负载因子设置为默认值 0.75，初始容量会在第一次插入元素时根据默认值 16 进行初始化。

5.2 指定初始容量的构造方法

public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

该构造方法允许指定 HashMap 的初始容量，负载因子使用默认值 0.75。

5.3 指定初始容量和负载因子的构造方法

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

此构造方法允许同时指定初始容量和负载因子。tableSizeFor 方法会将初始容量调整为大于等于该值的最小的 2 的幂次方。

5.4 从其他 Map 创建 HashMap 的构造方法

public HashMap(Map<? extends K, ? extends V> m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    putMapEntries(m, false);
}

该构造方法接受一个 Map 对象作为参数，将该 Map 中的所有键值对添加到新创建的 HashMap 中。

import java.util.HashMap;
import java.util.Map;

public class HashMapConstructors {
    public static void main(String[] args) {
        // 无参构造方法
        HashMap<String, Integer> hashMap1 = new HashMap<>();

        // 指定初始容量的构造方法
        HashMap<String, Integer> hashMap2 = new HashMap<>(20);

        // 指定初始容量和负载因子的构造方法
        HashMap<String, Integer> hashMap3 = new HashMap<>(15, 0.8f);

        // 从其他 Map 创建 HashMap 的构造方法
        Map<String, Integer> anotherMap = new HashMap<>();
        anotherMap.put("apple", 1);
        anotherMap.put("banana", 2);
        HashMap<String, Integer> hashMap4 = new HashMap<>(anotherMap);
        System.out.println(hashMap4);
    }
}

六、常用操作原理

6.1 插入元素（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;
    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;
}

put 方法的主要步骤如下：

  1. 计算键的哈希值：通过 hash(key) 方法计算键的哈希值。
  2. 检查数组是否为空：如果数组为空，则调用 resize() 方法进行初始化。
  3. 计算桶的索引：通过 (n - 1) & hash 计算键值对应该存储的桶的索引。
  4. 检查桶是否为空：如果桶为空，则直接创建一个新的节点放入桶中。
  5. 处理哈希冲突：如果桶不为空，检查第一个节点的键是否与要插入的键相同，如果相同则更新值；如果是红黑树节点，则调用红黑树的插入方法；如果是链表节点，则遍历链表，找到相同的键则更新值，否则在链表尾部插入新节点。如果链表长度超过 8，则将链表转换为红黑树。
  6. 检查是否需要扩容：插入新节点后，如果键值对的数量超过阈值，则调用 resize() 方法进行扩容。

6.2 获取元素（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) {
        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);
        }
    }
    return null;
}

get 方法的主要步骤如下：

  1. 计算键的哈希值：通过 hash(key) 方法计算键的哈希值。
  2. 检查数组和桶是否为空：如果数组为空或对应的桶为空，则返回 null。
  3. 检查第一个节点：如果第一个节点的键与要查找的键相同，则返回该节点的值。
  4. 处理链表或红黑树：如果第一个节点不是目标节点，判断是链表还是红黑树。如果是红黑树，则调用红黑树的查找方法；如果是链表，则遍历链表查找目标节点。

6.3 删除元素（remove 方法）

public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        else if ((e = p.next) != null) {
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)
                tab[index] = node.next;
            else
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

remove 方法的主要步骤如下：

  1. 计算键的哈希值：通过 hash(key) 方法计算键的哈希值。
  2. 检查数组和桶是否为空：如果数组为空或对应的桶为空，则返回 null。
  3. 查找目标节点：如果第一个节点是目标节点，则直接记录；如果不是，则判断是链表还是红黑树，分别进行查找。
  4. 删除节点：如果找到目标节点，根据节点类型（链表节点或红黑树节点）进行删除操作。如果是红黑树节点，调用红黑树的删除方法；如果是链表节点，将其从链表中移除。
  5. 更新修改次数和大小：删除节点后，更新 modCount 和 size。

6.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) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        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
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    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) {
        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;
}

resize 方法的主要步骤如下：

  1. 计算新的容量和阈值：如果旧容量大于 0，则将容量和阈值翻倍；如果旧容量为 0 且旧阈值大于 0，则将旧阈值作为新容量；如果旧容量和旧阈值都为 0，则使用默认的初始容量和阈值。
  2. 创建新的数组：根据新的容量创建一个新的数组。
  3. 迁移元素：遍历旧数组，将每个桶中的元素迁移到新数组中。如果是单个节点，直接计算新的桶索引并放入新数组；如果是红黑树节点，调用红黑树的拆分方法；如果是链表节点，将链表拆分为两个链表，分别放入新数组的不同位置。
import java.util.HashMap;
import java.util.Map;

public class HashMapOperations {
    public static void main(String[] args) {
        HashMap<String, Integer> hashMap = new HashMap<>();

        // 插入元素
        hashMap.put("apple", 1);
        hashMap.put("banana", 2);
        hashMap.put("cherry", 3);

        // 获取元素
        Integer value = hashMap.get("banana");
        System.out.println("Value of banana: " + value);

        // 删除元素
        hashMap.remove("cherry");
        System.out.println("After removing cherry: " + hashMap);

        // 扩容操作会在元素数量达到阈值时自动触发
    }
}

七、哈希函数与哈希冲突处理

7.1 哈希函数

HashMap 中的哈希函数用于计算键的哈希值，其实现如下：

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

该哈希函数将键的 hashCode 值的高 16 位与低 16 位进行异或运算，目的是让哈希值的高位也参与到桶索引的计算中，减少哈希冲突的概率。

7.2 哈希冲突处理

HashMap 使用链地址法来处理哈希冲突，即当多个键映射到同一个桶时，将这些键值对以链表或红黑树的形式存储在该桶中。当链表长度超过 8 且数组长度大于 64 时，链表会转换为红黑树，以提高查找效率。

八、性能分析

8.1 时间复杂度

  • 插入操作：平均情况下，插入操作的时间复杂度为 O(1)。因为哈希表可以通过哈希函数快速定位到桶的位置，在没有哈希冲突的情况下，插入操作可以在常数时间内完成。但在极端情况下，当所有元素都映射到同一个桶时，插入操作的时间复杂度会退化为 O(n)。
  • 查找操作：平均情况下，查找操作的时间复杂度为 O(1)。同样，哈希表可以通过哈希函数快速定位到桶的位置，然后在桶中查找元素。
  • 删除操作：平均情况下，删除操作的时间复杂度为 O(1)。通过哈希函数定位到桶的位置，然后在桶中删除元素。

8.2 空间复杂度

HashMap 的空间复杂度为 O(n)，主要用于存储数组、链表和红黑树节点。

九、注意事项

9.1 键的哈希码和相等性

HashMap 判断键是否相等是基于键的 hashCode() 和 equals() 方法。因此，存储在 HashMap 中的键必须正确重写这两个方法，否则可能会导致键值对的存储和查找出现问题。

9.2 线程安全问题

HashMap 不是线程安全的。如果在多线程环境下需要使用线程安全的 Map，可以考虑使用 ConcurrentHashMap 或使用 Collections.synchronizedMap() 方法将 HashMap 包装成线程安全的 Map。

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class HashMapThreadSafety {
    public static void main(String[] args) {
        HashMap<String, Integer> hashMap = new HashMap<>();
        Map<String, Integer> synchronizedMap = Collections.synchronizedMap(hashMap);
    }
}

9.3 初始容量和负载因子的选择

初始容量和负载因子会影响 HashMap 的性能。如果初始容量设置过小，会导致频繁的扩容操作，影响性能；如果负载因子设置过大，会增加哈希冲突的概率，降低查找效率。一般情况下，使用默认的初始容量和负载因子即可，但在某些场景下，可以根据实际情况进行调整。

十、总结

HashMap 是 Java 中一个非常重要且强大的数据结构，它通过哈希表（数组 + 链表 + 红黑树）实现了高效的键值对存储和查找。在插入、查找和删除操作上，平均时间复杂度为 O(1)。通过合理设计哈希函数和处理哈希冲突，HashMap 能够在大多数情况下提供良好的性能。但在使用时，需要注意键的哈希码和相等性的重写、线程安全问题以及初始容量和负载因子的选择。深入理解 HashMap 的原理和性能特点，有助于我们在实际开发中更好地利用它来解决各种问题。

Java HashMap 工作原理深度解析
记录学习的过程
04-25 839
HashMap 是 Java 集合框架中最重要且最常用的数据结构之一，它基于哈希表实现，提供了高效的键值对存储和检索能力。
深度解析HashMap集合底层原理
uuuyy_的博客
12-08 459
目录 前置知识 ==和equals的区别 为什么要重写equals和HashCode 时间复杂度 (不带符号右移) >>> ^异或运算 &（与运算） 位移操作：1<<2=4，1左移两位为什么等于4 HashMap集合特点及源码分析（JDK1.8） HashMap重要的五大点 1.集合初始化 HashMap成员变量 HashMap内部数据结构 链表 红黑树 HashMap构造方法
HashMap实现原理分析
冷血之心的博客
04-07 6515
之前转载过一篇HashMap相关分析文章，快速链接：HashMap实现原理分析 既然有前辈已经将源码分析总结了出来，我们在继续学习研究源码实现的时候不妨借鉴借鉴前人的总结与经验~ 本文转自：https://blog.csdn.net/hefenglian/article/details/79763634 深度好文，先转载过来，慢慢研究。 目录 一、底层数据结构 二、HashMap...
hashMap工作原理
08-11
详细介绍了hashMap原理，值得一看，对于面试者有很大帮助
HashMap深度解析(一)
热门推荐
寻道
11-22 14万+
HashMap可以说是Java中最常用的集合类框架之一，是Java语言中非常典型的数据结构，我们总会在不经意间用到它，很大程度上方便了我们日常开发。在很多Java的笔试题中也会问到，最常见的，“HashMap和HashTable有什么区别？”，这也不是三言两语能说清楚的，这种笔试题就是考察你来笔试之前有没有复习功课，随便来个快餐式的复习就能给出答案。
[翻译]Java HashMap工作原理
weixin_34024034的博客
09-02 385
大部分Java开发者都在使用Map，特别是HashMap。HashMap是一种简单但强大的方式去存储和获取数据。但有多少开发者知道HashMap内部如何工作呢？几天前，我阅读了java.util.HashMap的大量源代码（包括Java 7 和Java 8），来深入理解这个基础的数据结构。在这篇文章中，我会解释java.util.HashMap的实现，描述Java 8实现中添加的新特性，并讨论性能...
深入Java集合学习系列：HashMap的实现原理
weixin_34095889的博客
06-03 779
参考文献 引用文献：深入Java集合学习系列：HashMap的实现原理，大部分参考这篇博客，只对其中进行稍微修改 自己曾经写过的：Hashmap实现原理 1. HashMap概述： 　　HashMap是基于哈希表的Map接口的非同步实现（Hashtable跟HashMap很像，唯一的区别是Hashtalbe中的方法是线程安全的，也就是同步的）。此实现提供所有可选的映射操作，并允许使用nul...
深度解析HashMap的原理与应用
为了深入理解HashMap的工作原理，我们需要关注以下几个关键点： 1. **内部结构**： - **数组（ buckets ）**：用于存放键值对的容器，数组的每一个元素称为桶（bucket）。 - **链表（链式存储）**：Java 7及之前...
Java8源码深度解析：HashMap原理与实现
标题《java8源码-Interview:对我的采访》揭示了文档内容主要围绕Java 8源码特别是HashMap这一重要的集合框架数据结构进行探讨。HashMap是Java中常用的一种存储键值对的数据结构，它允许存储为null的键和值。本文将...
hashmap实现原理
10-15
hashmap的底层及源码解析，很适合大家的学习，不要积分。
Java的HashMap的工作原理是什么
01-08
hashmap是一个key-value键值对的数据结构，从结构上来讲在jdk1.8之前是用数组加链表的方式实现，jdk1.8加了红黑树，hashmap数组的默认初始长度是16，hashmap数组只允许一个key为null，允许多个value为null hashmap的内部实现，hashmap是使用数组+链表+红黑树的形式实现的，其中数组是一个一个Node[]数组，我们叫他hash桶数组，它上面存放的是key-value键值对的节点。HashMap是用hash表来存储的，在hashmap里为解决hash冲突，使用链地址法，简单来说就是数组加链表的形式来解决，当数据被hash后，得到数组下标，把数
HashMap数据结构与工作原理深度解析
"HashMap是Java编程中的一种重要数据结构，它是数组和链表的结合体，也称为链表散列。HashMap在初始化时会创建一个数组，每个数组元素实际上是一个链表，...理解其工作原理对于优化代码性能和解决潜在问题至关重要。
HashMap的工作原理是什么
浩瀚星空
05-30 544
HashMap的工作原理是近年来常见的Java面试题。几乎每个Java程序员都知道HashMap，都知道哪里要用HashMap，知道HashTable和HashMap之间的区别，那么为何这道面试题如此特殊呢？是因为这道题考察的深度很深。这题经常出现在高级或中高级面试中。投资银行更喜欢问这个问题，甚至会要求你实现HashMap来考察你的编程能力。ConcurrentHashMap和其它同步集合的引入...
HashMap的工作原理是什么？
m0_59002506的博客
06-28 402
HashMap在JDK1.8之前的实现方式 数组+链表, 但是在JDK1.8后对HashMap进行了底层优化,改为了由 数组+链表+红黑树实现,主要的目的是提高查找效率。 JDK版本 实现方式 节点数>=8 节点数<=6 1.8以前 数组+单向链表 数组+单向链表 数组+单向链表 1.8以后 数组+单向链表+红黑树 数组+红黑树 数组+单向链表 ...
HashMap 工作原理
The_flying_pig的博客
09-19 813
java
Java HashMap的工作原理
思考、总结、专注
04-11 1086
hashmap的工作原理 ：每当往hashmap里面存放key-value对的时候，都会为他们实例化一个entry对象，这个entry对象会存储到entry数组table中，它是根据key的hashcode方法计算出来的hash值决定的，hash值就是就算key在entry数组的索引。如果两个元素有相同的hashcode，他们会放在同一个索引上面，因为它是以链表的形式来存储的。 hash
Hashmap工作原理
lhj_sjtu的博客
04-14 259
public static void main(String[] args) { // TODO 自动生成的方法存根 String str = "abcaaaefdabbhg"; //count(str); HashMap&lt;String, Integer&gt; map = new HashMap&lt;String, In...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值