【java】面试经典之hashmap解读，并简单手写一个hashmap

最新推荐文章于 2026-05-26 21:28:04 发布
原创 最新推荐文章于 2026-05-26 21:28:04 发布 · 1.3k 阅读 · 6 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java
本文详细解析了HashMap的底层数据结构，包括hash函数、数组和单链表的运用，探讨了hash函数的设计原则，如何处理hash冲突，以及HashMap的扩容机制。同时，提供了自定义HashMap的实现代码，帮助读者更深入地理解其工作原理。

HashMap是在面试中经常会问的一点，很多时候我们仅仅只是知道HashMap他是允许键值对都是Null，并且是非线程安全的，如果在多线程的环境下使用，是很容易出现问题的。 这是我们通常在面试中会说的，但是有时候问到底层的源码分析的时候，为什么允许为Null，为什么不安全，这些问题的时候，如果没有分析过源码的话，好像很难回答， 这样的话我们来研究一下这个源码。看看原因吧。

  • 底层数据结构

第一，如图所示，HashMap有3个要素：hash函数+数组+单链表
第二，对于hash函数而言，需要考虑些什么？
要快，对于给定的Key，要能够快速计算出在数组中的index。那么什么运算够快呢？显然是位运算！
要均匀分布，要较少碰撞。说白了，我们希望通过hash函数，让数据均匀分布在数组中，不希望大量数据发生碰撞，导致链表过长。那么怎么办到呢？也是利用位运算，通过对数据的二进制的位进行移动，让hash函数得到的数据散列开来，从而减低了碰撞的概率。
如果发生了碰撞怎么办？上面的图其实已经说明了JDK的HashMap是如何处理hash冲突的，就是通过单链表解决的。那么除了这个方法，还有其他思路么？比如说，如果发生冲突，那么记下这个冲突的位置为index，然后在加上固定步长，即index+step，找到这个位置，看一下是否仍然冲突，如果继续冲突，那么按照这个思路，继续加上固定步长。其实这就是所谓的线性探测来解决Hash冲突的方法！

  • 定义一个Map接口

定义一个接口，对外暴露快速存取的方法。


```java
public interface Map<K,V> {
    //存值
    public V put(K k, V v);
    //取值
    public V get(K k);
}
  • 定义一个Entry链表

HashMap的要素之一，单链表的体现就在这里！

public class Entry<K, V> {
    K k;
    V v;
    Entry<K, V> next;
    public Entry() {
    }
    /**
     * 在next指向下一个节点
     */
    public Entry(K k, V v, Entry<K, V> next) {
        this.k = k;
        this.v = v;
        this.next = next;
    }
    public K getKey() {
        return k;
    }
    public V getValue() {
        return v;
    }
}
  • 实现Map接口
  • 重写有参/无参构造方法

仔细观察下，你会发现，其实这里使用到了“门面模式”。这里的2个构造方法其实指向的是同一个，但是对外却暴露了2个“门面”！

public class MyHashMap<K, V> implements Map<K, V> {

    //数组默认长度
    private final static int DEFAULT_INIT_CAPACITY = 1 << 4;
    //默认负载因子
    private final static float DEFAULT_LOAD_FACTOR = 0.75f;
    //初始定义的长度
    private int defaultInitCapacity;
    //初始定义的负载因子
    private float defaultLoadFactor;
    //实际的数组长度
    private int userSize;

    //entry数组
    Entry<K, V>[] tables;

    //无参构造
    public MyHashMap() {
        this(DEFAULT_INIT_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

    //有参构造
    public MyHashMap(int defaultInitCapacity, Float defaultLoadFactor) {
        if (defaultInitCapacity < 0) {
            throw new IllegalArgumentException("初始长度不能是0" + defaultInitCapacity);
        }
        if (defaultLoadFactor <= 0 || Float.isNaN(defaultLoadFactor)) {
            throw new IllegalArgumentException("负载因子错了！" + defaultLoadFactor);
        }
        this.defaultInitCapacity = defaultInitCapacity;
        this.defaultLoadFactor = defaultLoadFactor;

        this.tables = new Entry[this.defaultInitCapacity];
    }
}
  • 存值put

第一，要考虑是否扩容？ HashMap中的Entry的数量（数组以及单链表中的所有Entry）是否达到阀值？
第二，如果扩容，意味着新生成一个Entry[]，不仅如此还得重新散列。
第三，要根据Key计算出在Entry[]中的位置，定位后，如果Entry[]中的元素为null，那么可以放入其中，如果不为空，那么得遍历单链表，要么更新value，要么形成一个新的Entry“挤压”单链表！

 //存值
    @Override
    public V put(K k, V v) {
        //判断是否需要扩容
        if (this.userSize > this.defaultInitCapacity * this.defaultLoadFactor) {
            this.resize();
        }
        //计算出当前下标
        int index = this.getIndex(k, this.defaultInitCapacity);
        //获取下标上的entry
        Entry<K, V> entry = this.tables[index];
        //创建一个新的newEntry
        Entry<K, V> newEntry = new Entry<K, V>(k, v, null);
        //判断当前下标是否被使用，如果没有就将newEntry填入
        if (entry == null) {
            this.tables[index] = newEntry;
            //使用后，使用长度+1
            this.userSize++;
        } else {
            Entry<K, V> e = entry;
            //判断当前key是否等于传入的k
            if (e.getKey() == k) {
                //如果相等，就将传入v赋值给e.v
                e.v = v;
            } else {
                //如果不相等，就循环遍历entry的下一个entry.next
                while (e.next != null) {
                    //判断如果下一个entry的key是否等于传入的k，如果相等就赋值v
                    if (e.next.getKey() == k || e.next.getKey().equals(k)) {
                        e.next.v = v;
                    } else {
                        e = e.next;
                    }
                }
                //判断上边循环后entry.next是否等于null，如果等于null
                //将newEntry设置到entry.next的位置
                if (e.next == null) {
                    e.next = newEntry;
                }
            }
        }
        // 返回newEntry.getValue()
        return newEntry.getValue();
    }
  • 取值get

get很简单，只需要注意在遍历单链表的过程中使用== or equals来判断下即可。

    //取值
    @Override
    public V get(K k) {
        // 获取当前下标
        int index = this.getIndex(k, this.tables.length);
        // 得到下标上的entry
        Entry<K, V> entry = this.tables[index];
        // entry非空校验
        if (entry == null) {
            throw new NullPointerException("空空如也");
        }

        // 循环entry != null
        while (entry != null) {
            // key相等就返回
            if (entry.getKey() == k || entry.getKey().equals(k)) {
                return entry.getValue();
            } else {
                // 如果不相等，将next赋值给entry继续循环
                entry = entry.next;
            }
        }
        // 找不到就返回null
        return null;
    }
  • 计算hashcode

我这里参考了JDK的HashMap的hash函数的实现，这里也再次说明了：要想散列均匀，就得进行二进制的位运算！

    //计算hashcode
    private int hash(int hashCode) {
        hashCode = hashCode ^ ((hashCode >>> 20) ^ (hashCode >>> 12));
        return hashCode ^ ((hashCode >>> 7) ^ (hashCode >>> 4));
    }
  • 扩容resize

这里可以看出，对于HashMap而言，如果频繁进行resize/rehash操作，是会影响性能的。
resize/rehash的过程，就是数组变大，原来数组中的entry元素一个个的put到新数组的过程，需要注意的是一些状态变量的改变。

    //扩容
    private void resize() {
        // 创建一个新的entry数组 ，长度为 defualtLength*2
        Entry<K, V>[] newEntryTable = new Entry[this.defaultInitCapacity * 2];

        // 创建一个list 用来存放entry
        List<Entry<K, V>> entryList = new ArrayList<Entry<K, V>>();

        // 1.先将历史的数据保存
        // 循环entry数组
        for (int i = 0; i < tables.length; i++) {
            Entry<K, V> entry = tables[i];
            // 判断数组下标上的entry!=null
            while (entry != null) {
                entryList.add(entry);
                // 将enrty存到list中，entry = entry.next;
                entry = entry.next;
            }
        }

        // 非空校验list
        if (entryList != null && entryList.size() > 0) {
            // 重新设置默认长度
            this.defaultInitCapacity = this.defaultInitCapacity * 2;
            // 使用长度重置为0
            this.userSize = 0;
            // 将newtable赋值给table
            this.tables = newEntryTable;
            // 2.将保存好的数据存到新的容器中
            for (Entry<K, V> entry : entryList) {
                // 循环list中的entry，并将其next置位null
                if (entry.next != null) {
                    entry.next = null;
                }
                // 调用put方法,传入entry.k entry.v
                put(entry.getKey(), entry.getValue());
            }
        }
    }
  • 测试代码
public class Test1 {

    public static void main(String[] args) {

        Map<String,Integer> map = new MyHashMap<>();
        for(int i=0;i<10000;i++){
            map.put(""+i, i);
        }

        for(int i=0;i<10000;i++){
            System.out.println("key:"+i+"value:"+map.get(""+i));
        }
    }
    
}
  • 测试结果
    在这里插入图片描述
    全部代码一览
package hashmap;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: wangpeng
 * @Date: 2020-8-10 23:01
 */
public class MyHashMap<K, V> implements Map<K, V> {

    //数组默认长度
    private final static int DEFAULT_INIT_CAPACITY = 1 << 4;
    //默认负载因子
    private final static float DEFAULT_LOAD_FACTOR = 0.75f;
    //初始定义的长度
    private int defaultInitCapacity;
    //初始定义的负载因子
    private float defaultLoadFactor;
    //实际的数组长度
    private int userSize;

    //entry数组
    Entry<K, V>[] tables;

    //无参构造
    public MyHashMap() {
        this(DEFAULT_INIT_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

    //有参构造
    public MyHashMap(int defaultInitCapacity, Float defaultLoadFactor) {
        if (defaultInitCapacity < 0) {
            throw new IllegalArgumentException("初始长度不能是0" + defaultInitCapacity);
        }
        if (defaultLoadFactor <= 0 || Float.isNaN(defaultLoadFactor)) {
            throw new IllegalArgumentException("负载因子错了！" + defaultLoadFactor);
        }
        this.defaultInitCapacity = defaultInitCapacity;
        this.defaultLoadFactor = defaultLoadFactor;

        this.tables = new Entry[this.defaultInitCapacity];
    }

    //计算hashcode
    private int hash(int hashCode) {
        hashCode = hashCode ^ ((hashCode >>> 20) ^ (hashCode >>> 12));
        return hashCode ^ ((hashCode >>> 7) ^ (hashCode >>> 4));
    }

    //获取保存位置的数组下标
    private int getIndex(K k, int length) {
        //减1后，下标永远不会大于16
        int m = length - 1;
        int index = hash((k.hashCode())) & m;
        return index > 0 ? index : -index;
    }

    //存值
    @Override
    public V put(K k, V v) {
        //判断是否需要扩容
        if (this.userSize > this.defaultInitCapacity * this.defaultLoadFactor) {
            this.resize();
        }
        //计算出当前下标
        int index = this.getIndex(k, this.defaultInitCapacity);
        //获取下标上的entry
        Entry<K, V> entry = this.tables[index];
        //创建一个新的newEntry
        Entry<K, V> newEntry = new Entry<K, V>(k, v, null);
        //判断当前下标是否被使用，如果没有就将newEntry填入
        if (entry == null) {
            this.tables[index] = newEntry;
            //使用后，使用长度+1
            this.userSize++;
        } else {
            Entry<K, V> e = entry;
            //判断当前key是否等于传入的k
            if (e.getKey() == k) {
                //如果相等，就将传入v赋值给e.v
                e.v = v;
            } else {
                //如果不相等，就循环遍历entry的下一个entry.next
                while (e.next != null) {
                    //判断如果下一个entry的key是否等于传入的k，如果相等就赋值v
                    if (e.next.getKey() == k || e.next.getKey().equals(k)) {
                        e.next.v = v;
                    } else {
                        e = e.next;
                    }
                }
                //判断上边循环后entry.next是否等于null，如果等于null
                //将newEntry设置到entry.next的位置
                if (e.next == null) {
                    e.next = newEntry;
                }
            }
        }
        // 返回newEntry.getValue()
        return newEntry.getValue();
    }

    //取值
    @Override
    public V get(K k) {
        // 获取当前下标
        int index = this.getIndex(k, this.tables.length);
        // 得到下标上的entry
        Entry<K, V> entry = this.tables[index];
        // entry非空校验
        if (entry == null) {
            throw new NullPointerException("空空如也");
        }

        // 循环entry != null
        while (entry != null) {
            // key相等就返回
            if (entry.getKey() == k || entry.getKey().equals(k)) {
                return entry.getValue();
            } else {
                // 如果不相等，将next赋值给entry继续循环
                entry = entry.next;
            }
        }
        // 找不到就返回null
        return null;
    }

    //扩容
    private void resize() {

        // 创建一个新的entry数组 ，长度为 defualtLength*2
        Entry<K, V>[] newEntryTable = new Entry[this.defaultInitCapacity * 2];

        // 创建一个list 用来存放entry
        List<Entry<K, V>> entryList = new ArrayList<Entry<K, V>>();

        // 1.先将历史的数据保存
        // 循环entry数组
        for (int i = 0; i < tables.length; i++) {
            Entry<K, V> entry = tables[i];
            // 判断数组下标上的entry!=null
            while (entry != null) {
                entryList.add(entry);
                // 将enrty存到list中，entry = entry.next;
                entry = entry.next;
            }
        }

        // 非空校验list
        if (entryList != null && entryList.size() > 0) {
            // 重新设置默认长度
            this.defaultInitCapacity = this.defaultInitCapacity * 2;
            // 使用长度重置为0
            this.userSize = 0;
            // 将newtable赋值给table
            this.tables = newEntryTable;
            // 2.将保存好的数据存到新的容器中
            for (Entry<K, V> entry : entryList) {
                // 循环list中的entry，并将其next置位null
                if (entry.next != null) {
                    entry.next = null;
                }
                // 调用put方法,传入entry.k entry.v
                put(entry.getKey(), entry.getValue());
            }
        }
    }
}
HashMap源码解读—Java8版本
开源项目 rich-agent、biga作者。
01-07 3814
人有两次生命，一次是出生，一次是觉醒，希望我们可以在风华正茂时重获新生，而不是在垂暮之年幡然醒悟。
面试必备：《Java 最常见 200+ 面试题全解析》
热门推荐
GitChat
05-29 4万+
毕业在即，想让面试官在短短的几十分钟内就认可你的能力？ 想在最快的时间内收获 Java 技术栈最核心的知识点？ 想要更全面、更深入的了解 Java 技术？ 这里能够给你想要的所有答案
HashMap源码手写简易篇（数组+链表）
qq_43649937的博客
03-02 799
java
手写一个HashMap（附demo，有注释，复制就能跑）
秃头计划——启动！
01-05 1420
手写HashMap，你上你也行！
＜＜吃透哈希表：从原理到手写实现＞＞
最新发布
2403_87212593的博客
05-26 794
不同 key 经过哈希计算得到相同下标 →哈希冲突1. 哈希表是 C++ 最核心高频的数据结构2. unordered_map / set 底层是 vector+链表拉链法3. 模板适配器思想是 STL 精髓4. 手写一遍底层，彻底告别只会调用不会原理。
面试必问：HashMap底层原理详解＋用Java代码手写简易实现HashMap
weixin_44868739的博客
03-09 1060
目录HashMap简介快速入门技术的本质数据结构：数组、链表算法：哈希算法（散列）哈希算法和哈希碰撞哈希算法简介哈希碰撞（哈希冲突）什么是哈希碰撞？如何用链表数据结构解决手写实现hashmap为什么要在jdk8之后用红黑树来实现？用纯数组+链表实现带来的问题红黑树简介红黑树的结构特点红黑树和链表性能对比为什么在jdk1.8中红黑树的阈值设为8？ HashMap简介 简单来说，hashmap是一种用于存储key-value键值对的数据结构。 快速入门 存储：put（） 查询：get（） 技术的本质 我们说程序
手写简易HashMap解决Hash碰撞演示
weixin_39831786的博客
04-01 585
首先定义一个接口，代码如下 public interface JxdMap<K, V> { int size(); V put(K key, V value); V get(K key); /** * 存放键值对 */ interface Entry<K, V> { K getKey(); ...
京东太猛，手写hashmap又一次重现江湖
架构师尼恩
05-17 2万+
在40岁老架构师 尼恩的读者社群(50+)中，最近有小伙伴拿到了一线互联网企业如京东、极兔、有赞、希音、百度、网易的面试资格，遇到一个很重要的面试题：尼恩读者反馈说，之前总是听人说，大厂喜欢手写hashmap、手写线程池，这次终于碰到了。和线程池的知识一样，hashmap既是面试的核心知识，又是开发的核心知识。手写线程池，之前已经通过博客、公众号的形式已经发布：网易一面：如何设计线程池？请手写一个简单线程池？在这里，老架构尼恩再接再厉，和架构师唐欢一块，给大家做一下手写hashmap系统化、体系化的线程池
【从零开始学习JAVA重要知识 | 第一篇】深入解读HashMap源码（含面试题）
fckbb的博客
12-13 1971
HashMap是 Java 中的一个常用数据结构，用于存储键值对它基于哈希表（hash table）实现，允许 null 键和 null 值，并且具有快速的查找、插入和删除操作。HashMap 继承自抽象类 AbstractMap，并且实现了 Map 接口。这
新所得库 - Java集合 - HashMap & TreeMap源码解读实战篇
tang7mj的博客
04-19 1444
HashMap为什么需要链表+红黑树混合？红黑树的转换阈值是多少？为什么设定为8？TreeMap添加元素是否需要实现 hashCode/equals？（不需要）HashMap的键为什么不需要实现 Comparable？TreeMap和HashMap谁更快？（大多数场景HashMap更快）│ 计算 hash值 │↓│ 计算桶索引 i │↓│ tab[i] 为空？│是 否↓ ↓创建新节点 哈希冲突判断├ 链表插入└ 红黑树插入put() 的底层流程是怎样的？为什么要使用高位扰动？
浅谈HashMap原理，并手写HashMap并实现部分区块链特征
liaoyue11的博客
01-27 333
浅谈HashMap原理，并手写HashMap并实现部分区块链特征 写在前面 最近有很多的粉丝私信我，说自己在面试的时候，老是被人问HashMap的原理，但是在实际的工作中，也只是使用HashMap，从来就没有关注过它的原来，今天博主本人，根据自己的实际经验，浅谈一下HashMap的实现原理。并附上自己根据原理，手写的MHashMap，并且还带上了部分区块链的特征。 JDK7和JDK8中的HashMap JDK7：数组和链式结构 JDK8：数组和链式结构，红黑树 两者之间的区别就是，JDK8中加上了红黑树。
面试查漏补缺--java基础-容器源码解读
weixin_46643875的博客
10-25 608
面试查漏补缺--java基础-容器源码解读
红黑树图解指南：为什么Linux内核和Java HashMap都用它？手写插入删除全流程
assembly8low的博客
02-26 996
本文深入解析红黑树（Red-Black Tree）的核心原理与工业级应用。通过图解详细拆解其插入与删除操作流程，揭示其以近似平衡换取稳定O(log n)性能的工程智慧，并探讨其被Linux内核CFS调度器与Java HashMap选中的根本原因，在于其卓越的动态操作性能与相对较低的维护成本。
从HashMap到ConcurrentHashMap，面试官究竟在考什么？
m0_71836706的博客
06-27 1000
HashMap 和 ConcurrentHashMap 就像是 Java 集合家族中的两位得力干将，各自在不同的领域发光发热。HashMap 以其在单线程环境下的简单高效，成为日常开发中处理键值对数据的首选工具；而 ConcurrentHashMap 则凭借出色的线程安全机制和高并发性能，在多线程的复杂场景中独领风骚。​希望通过本文的剖析，能帮助大家在面试中对这两个集合类的问题应对自如。同时，集合框架博大精深，HashMap 和 ConcurrentHashMap 只是其中的冰山一角。
HashMap源码解读(面试题剖析)
莫安逸无风雪
06-16 908
HashMap源码深度剖析，对几个有意思的方法进行了分析，如初始化容量如果转换为2的n次幂，扩容过程，存储和获取对象方法，以及面试题的总结
Java|HashMap源码解读
笔记本
06-17 672
HashMap 和 Hashtable 区别： Hashtable 是一个线程安全的 Map 实现，HashMap 是线程不安全的实现，HashMap 比 Hashtable 性能高 Hashtable 不允许使用 null 作为 key 和 value，如果试图把 null 值放进 Hashtable 中，将会引发 NullPointerException 异常；但 HashMap 可以使用 ...
我把面试问烂了的⭐Java集合⭐总结了一下（带答案，万字总结，精心打磨，建议收藏）
java程序鱼的博客
09-13 3万+
我把面试问烂了的⭐Java集合⭐总结了一下（带答案，万字总结，精心打磨，建议收藏）
《每天读一个JDK源码》之HashMap解读
dhrmt的博客
03-01 1051
截自某平台的的评论区对比维度JDK1.7JDK1.8数据结构数组+链表数组+链表/红黑树哈希计算9次位扰动2次位扰动节点插入头插法尾插法扩容后索引计算全部重新计算hash利用高位bit判断最大容量1<<301<<30（但实际受VM限制）
Java面试必备：通俗易懂的搞定HashMap源码
weixin_47955802的博客
11-30 2321
前言 最沉稳知礼平生最恨是邪途，即一字情行世间不寂，利不要面试时不要临时抱佛脚，本觉 网易Java社招面试经历分享 一面： 1、简单介绍一下自己。 2、介绍一下你的项目经历。 3、讲一下你在这个项目中用到的技术，负责哪个模块？ 4、在项目过程中有没有遇到什么困难，怎么去解决的？ 5、Spring具有什么特点（IOC和AOP） 6、HashMap和HashSet的实现原理。 7、动态代理的原理。 8、java虚拟机类加载机制。 9、java虚拟机GC算法。 10、包装类型和基本类型的比较问题。 11、Inte
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值