仿写HashMap，思路清晰

已于 2022-03-21 00:39:13 修改
阅读量736 收藏 1
点赞数 1
分类专栏： 源码仿写 Java基础 文章标签： java hashmap
于 2022-03-19 13:51:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46116099/article/details/123592276
版权
本文通过阅读HashMap源码，详细介绍了HashMap的工作原理，包括容量、负载因子、数组和链表的使用。作者尝试仿写HashMap，实现了put、get和resize方法，探讨了Hash值计算、数组扩容及冲突解决策略。同时，文章还讨论了Java中泛型数组的实例化问题以及为何使用&(capacity-1)来计算索引。
摘要由CSDN通过智能技术生成

最近在看HashMap的源码，了解了HashMap的原理和方法实现的过程，觉得如果自己仿写可以简单仿写一个HashMap可能就会更加清楚了，说干就干。

说明一下，我主要仿写了put、get和扩容resize方法，其他方法其实大致原理差不多。

源码已上传到GitHub上：仿写HashMap

准备工作

首先，HashMap的底层是一个数组，数组中的元素Node有四个属性，Key，Value，Key的Hash值和为了解决产生Hash冲突而设置的Next结点，如下：

class Node<K,V>{
    K key;
    V value;
    int hash;
    Node<K,V> next;

    public Node(K key, V value, int hash) {
        this.key = key;
        this.value = value;
        this.hash = hash;
    }
}

在HashMap中，大体上有HashMap容量capacity，负载因子loadFactor，元素数量size（还没put元素，肯定是0）和Node泛型数组这四个属性。

public class MyHashMap<K,V> {
    private int size = 0;
    private int capacity;
    private float loadFactor;
    private Node<K,V>[] table;
}

对于构造函数，HashMap默认容量是16，默认负载因子是0.75，还要创建一个大小为16的Node泛型数组，这里我一开始是这样写的

public class MyHashMap<K,V> {
    private int size = 0;
    private int capacity;
    private float loadFactor;
    private Node<K,V>[] table;
    
    public MyHashMap() {
        this.capacity = 16;
        this.loadFactor = 0.75f;
        table = new Node<K,V>[capacity];
    }  
}

发现new Node<K,V>[capacity];报错了，在网上搜索才知道Java是不支持实例化泛型数组的，因为Java认为数组是不可变的，而泛型数组中的元素类型是会变化的，后来查了一些资料，发现了一个解决方法，这样利用反射就可以实例化一个固定大小的泛型数组了，如下：

public class MyHashMap<K,V> {
    private int size = 0;
    private int capacity;
    private float loadFactor;
    private Node<K,V>[] table;
    
    public MyHashMap() {
        this.capacity = 16;
        this.loadFactor = 0.75f;
        table = (Node<K, V>[]) Array.newInstance(Node.class,capacity);
    }  
}

HashMap源码中还给出了一个可以自定义容量和负载因子的构造函数，我们也模仿着写一个，注意参数的合法性（其实HashMap源码中还限制了容量的最大值，为1<<30，也可以限制一下）

public class MyHashMap<K,V> {
    private int size = 0;
    private int capacity;
    private float loadFactor;
    private Node<K,V>[] table;
    
    public MyHashMap() {
        this.capacity = 16;
        this.loadFactor = 0.75f;
        table = (Node<K, V>[]) Array.newInstance(Node.class,capacity);
    }  
    
    //可以自定义容量和负载因子的构造器
    public MyHashMap(int initialCapacity,float loadFactor) {
        //自定义容量不能小于0
        if (initialCapacity < 0)
            throw new IllegalArgumentException("不合法容量: " +
                    capacity);
        //自定义负载因子不能小于等于0并且不能是NaN值
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("不合法负载因子: " +
                    loadFactor);
        //自定义容量向上取2的n次方
        this.capacity = tableSizeFor(initialCapacity);
        this.loadFactor = loadFactor;
        table = (Node<K, V>[]) Array.newInstance(Node.class,capacity);
    }
}

在HashMap中，容量必须为2的n次方，这个和生成Hash值有关，后面我会讲一下，而如果自定义的容量不为2的n次方，就会向上取一个最小的2的n次方的数，比如自定义容量为9，HahsMap就会自动将容量变为16，所以我这里调用了一个tableSizeFor方法来实现，参考了HashMap源码中的tableSizeFor方法，如下：

    //向上取2的n次方
    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 + 1;
    }

在写put和get方法的之前，我们还要写一个Hash方法，目的是为了计算Key的Hash值以得到它在数组中的索引位置，后面会讲一下原理，如下：

    //计算Hash值
    int Hash(K key) {
        return Objects.hashCode(key) & (capacity - 1);
    }

这里和HashMap源码中的Hash方法一样，也用HashCode值与capacity-1，那么为什么要这样做呢，& capacity不是也可以得到索引的位置吗？
这里就涉及到了一道面试题，就是为什么要&(capacity - 1)，原因就在于：HashMap规定数组的容量必需是2的n次方，不是的话向上取最小的2的n次方，当容量为2的n次方的时候，length-1会把二进制中1以后的0全部变为1，当hashcode值和length-1做与时，生成的hash值都是按照hashcode值生成的，减少了hash冲突。
如果length不为2的n次方的话，length-1就会在某些位上出现0，做与后就是0，浪费了空间，生成的hash值很可能出现重复，发生hash冲突的几率提高
如果直接&capacity，由于capacity是2的n次方，后果可想而知
所以HashMap既限制了capacity是2的n次方，又使用&(capacity - 1)，是减少Hash冲突最有效的方法。

至此，准备工作就做完了，可以开始写我们的put、get和resize方法了，先把之前写的整理一下：

public class MyHashMap<K,V> {
    private int size = 0;
    private int capacity;
    private float loadFactor;
    private Node<K,V>[] table;

    public MyHashMap() {
        this.capacity = 16;
        this.loadFactor = 0.75f;
        table = (Node<K, V>[]) Array.newInstance(Node.class,capacity);
    }

    public MyHashMap(int initialCapacity,float loadFactor) {
        //自定义容量不能小于0
        if (initialCapacity < 0)
            throw new IllegalArgumentException("不合法容量: " +
                    capacity);
        //自定义负载因子不能小于等于0并且不能是NaN值
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("不合法负载因子: " +
                    loadFactor);
        //自定义容量向上取2的n次方
        this.capacity = tableSizeFor(initialCapacity);
        this.loadFactor = loadFactor;
        table = (Node<K, V>[]) Array.newInstance(Node.class,capacity);
    }

    //计算Hash值
    int Hash(K key) {
        return Objects.hashCode(key) & (capacity - 1);
    }

    //向上取2的n次方
    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 + 1;
    }
	
	//put、get、resize
	
}
class Node<K,V>{
    K key;
    V value;
    int hash;
    Node<K,V> next;

    public Node(K key, V value, int hash) {
        this.key = key;
        this.value = value;
        this.hash = hash;
    }
}

put方法

先写put方法吧，我这里就不考虑jdk1.8新加的红黑树了，使用的是数组加链表，思考一下HashMap的put方法的大致流程：

  • 调用Hash方法计算得到key的Hash值，也就是索引位置
  • 判断索引位置处是否有元素，如果没有元素，直接加进去，如果有元素，就要遍历链表了
  • 遍历链表，判断每个结点的key是不是等于要加进去结点的key，如果有等于的，直接此结点覆盖value，如果没有等于的，利用头插法插到链表的第一个结点之前（这里也可以使用尾插法，注意要让最后一个结点的next指向新结点）
  • 判断一下是否发生覆盖，如果没有发生覆盖，size++
  • 判断size是否超过负载因子*容量，超过则扩容，调用resize

以上是大致思路，头插法和尾插法都有写，用一个就行，下面是具体代码实现：

    void put(K key,V value){
        int hash = Hash(key);
        //判断是否发生覆盖的标识
        boolean flag = true;
        Node<K,V> node = new Node<>(key,value,hash);
        //如果索引位置没有元素，直接加
        if(this.table[hash] == null){
            this.table[hash] = node;
        }else{
            Node<K,V> head = this.table[hash];
            //发生hash冲突，搜索链表
            while (head != null){
                //如果Key相等，覆盖Value
                if(key == head.key){
                    head.value = value;
                    flag = false;
                    break;
                }
                
//                //如果hash冲突没有发生覆盖，使用尾插法，让最后一个结点的next指向新结点
//                if(head.next == null){
//                    head.next = node;
//                    break;
//                }

                head = head.next;
            }
            
            //如果hash冲突没有发生覆盖，使用头插法，插到第一个结点之前
            if(flag){
                head = this.table[hash];
                this.table[hash] = node;
                node.next = head;
            }
            
        }
        //如果没有发生覆盖，元素数量size++
        if(flag) this.size++;
        //如果元素数量超过负载因子*容量，扩容
        if(size > capacity * loadFactor) resize();
    }

get方法

接下来写get方法，也是先思考一下大致流程：

  • 调用Hash方法计算得到key的Hash值，也就是索引位置
  • 如果索引位置没有元素，直接返回null
  • 如果索引位置有元素，遍历索引位置处的所有结点，找到key一样的就取得value，找不到返回null
    V get(K key){
        V value = null;
        int hash = Hash(key);
        //如果索引位置没有元素
        if(this.table[hash] == null){
            return value;
        }else{
            Node<K,V> head = this.table[hash];
            //遍历所有结点
            while (head != null){
                if(head.key == key){
                    value = head.value;
                    break;
                }
                head = head.next;
            }
            return value;
        }
    }

resize方法

最后是resize方法，这个方法是用来扩容的，HashMap扩容的时机为元素数量size大于负载因子loadFactor*容量capacity时，在jdk1.8中，如果链表元素超过8并且元素数量小于64时也会发生扩容，后者先不实现，先实现前者，也是思考一下大致流程：

  • 拷贝一下老数组，实例化一个是原数组容量2倍的新数组作为HashMap的数组，并把capacity乘以2。
  • 老数组中有所有元素，遍历老数组，如果某个索引处不为null，就遍历该索引位置的所有结点，每个结点都调用put方法加到新数组中，直到遍历完老数组为止。
    void resize(){
        //老的table
        Node<K,V>[] oldTable = this.table;
        //新的table，容量2倍
        this.table = (Node<K, V>[]) Array.newInstance(Node.class,2 * capacity);
        this.capacity *= 2;
        //遍历老table，把键值对都put到新table中
        for (int i = 0;i < oldTable.length; i++){
            if(oldTable[i] != null){
                Node<K,V> head = oldTable[i];
                while (head != null) {
                    put(head.key,head.value);
                    head = head.next;
                }
            }
        }
    }

至此，我自己仿写的HashMap在基础功能上就做完了，完整代码如下：

public class MyHashMap<K,V> {
    private int size = 0;
    private int capacity;
    private float loadFactor;
    private Node<K,V>[] table;

    public MyHashMap() {
        this.capacity = 16;
        this.loadFactor = 0.75f;
        table = (Node<K, V>[]) Array.newInstance(Node.class,capacity);
    }

    public MyHashMap(int initialCapacity,float loadFactor) {
        //自定义容量不能小于0
        if (initialCapacity < 0)
            throw new IllegalArgumentException("不合法容量: " +
                    capacity);
        //自定义负载因子不能小于等于0并且不能是NaN值
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("不合法负载因子: " +
                    loadFactor);
        //自定义容量向上取2的n次方
        this.capacity = tableSizeFor(initialCapacity);
        this.loadFactor = loadFactor;
        table = (Node<K, V>[]) Array.newInstance(Node.class,capacity);
    }

    //计算Hash值
    int Hash(K key) {
        return Objects.hashCode(key) & (capacity - 1);
    }


    void put(K key,V value){
        int hash = Hash(key);
        //判断是否发生覆盖
        boolean flag = true;
        Node<K,V> node = new Node<>(key,value,hash);
        if(this.table[hash] == null){
            this.table[hash] = node;
        }else{
            Node<K,V> head = this.table[hash];
            //发生hash冲突，搜索链表
            while (head != null){
                //如果Key相等，覆盖Value
                if(key == head.key){
                    head.value = value;
                    flag = false;
                    break;
                }
                //如果hash冲突没有发生覆盖，使用尾插法，让最后一个结点的next指向新结点
                if(head.next == null){
                    head.next = node;
                    break;
                }
                head = head.next;
            }
//            //如果hash冲突没有发生覆盖，使用头插法，插到第一个结点之前
//            if(flag){
//                head = this.table[hash];
//                this.table[hash] = node;
//                node.next = head;
//            }
        }
        if(flag) this.size++;
        //如果元素数量超过负载因子*容量，扩容
        if(size > capacity * loadFactor) resize();
    }

    V get(K key){
        V value = null;
        int hash = Hash(key);
        if(this.table[hash] == null){
            return value;
        }else{
            Node<K,V> head = this.table[hash];
            while (head != null){
                if(head.key == key){
                    value = head.value;
                    break;
                }
                head = head.next;
            }
            return value;
        }
    }

    void resize(){
        //老的table
        Node<K,V>[] oldTable = this.table;
        //新的table，容量2倍
        this.table = (Node<K, V>[]) Array.newInstance(Node.class,2 * capacity);
        this.capacity *= 2;
        //遍历老table，把键值对都put到新table中
        for (int i = 0;i < oldTable.length; i++){
            if(oldTable[i] != null){
                Node<K,V> head = oldTable[i];
                while (head != null) {
                    put(head.key,head.value);
                    head = head.next;
                }
            }
        }
    }

    //向上取2的n次方
    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 + 1;
    }

}
class Node<K,V>{
    K key;
    V value;
    int hash;
    Node<K,V> next;

    public Node(K key, V value, int hash) {
        this.key = key;
        this.value = value;
        this.hash = hash;
    }
}

自己也只是按照流程仿写了一下，许多HashMap中的方法都没有写，目的只是为了加深自己对HashMap的认识，其中可能也有不足的地方需要指正

ZZYSY~
关注
专栏目录
hashMap实现原理
yjclsx的博客
07-31 43万+
1. HashMap概述： 　　HashMap是基于哈希表的Map接口的非同步实现（Hashtable跟HashMap很像，唯一的区别是Hashtalbe中的方法是线程安全的，也就是同步的）。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 2. HashMap的数据结构： 　　在java编程语言中，最基本的结构就是两种，一...
仿写Map()方法
舜岳的博客
09-20 186
仿写es6的 new Map()： <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <meta htt...
Java，这是一个模仿HashMap的put，get功能的自定义MyHashMap
小电玩
12-12 1251
这段代码实现了一个简化版本的 HashMap，包含了 put 和 get 方法，并使用了数组+链表的存储结构。注意，这里的红黑树部分并未实现，只使用了链表来处理冲突。由于短时间没有办法能按自己的方式写出来全部的功能和底层设计，难度还是比较大的后期我会慢慢的把存储结构改成数组+链表+红黑树的数据结构
手写假HashMap1
qq_44741568的博客
10-06 312
记录的视频地址:blbl Map1.java public interface Map1<K,V> { //map的put和get和size方法 V put(K k,V v); //put方法 V get(K k); //get方法 int Size(); //map的长度 //每个键值对都是一个Entry对象 interface Entry<K,V> { K getKey(); //获取Entry的key
Java 手写设计HashMap源码，让面试官膜拜
小电玩
12-10 751
这是一个简单的自定义哈希映射（HashMap）的实现。功能不太完善，代码不太优雅，细节不够好，没有源码的那么好。后面我会慢慢进行优化。
HashMap源码仿写详解
weixin_56289362的博客
04-04 717
今天没有研究技术，所以想着仿写一遍简单的hashmap源码，仅供参考，实现方法有很多 我采用的尾插发，并实现了自动扩容，红黑树太复杂了，你可以看成是jdk1.7的简化hashmap ，实现了指定table长度构造，put ，contains，扩容，get import java.util.Arrays; import java.util.HashMap; /** * \* Created with IntelliJ IDEA. * \* @author: zth * \* Date: 2
HashMap 源码分析
12-22
《HashMap 源码解析——JDK11版本》 HashMap是Java中广泛使用的非同步散列表，其设计和实现是高效且灵活的。在JDK1.8之前，HashMap的底层数据结构采用的是数组+链表的方式，这种方式称为“拉链法”来解决哈希冲突。...
hashmap面试题_hashmap_
10-01
《HashMap面试题详解》 HashMap作为Java集合框架中的重要成员，是面试中常见的知识点，尤其在数据结构与算法、并发编程以及JVM内存管理等领域，HashMap的深入理解至关重要。本篇将围绕HashMap的相关面试题，从基础...
易语言HashMap类
07-18
易语言HashMap类是一种在易语言编程环境中实现的高效数据结构，它主要用于存储键值对（key-value pairs），提供快速的数据存取。HashMap类基于哈希表（Hash Table）原理，通过计算键的散列值来确定数据在内存中的...
C语言实现hashMap
11-10
C语言实现hashMap，包含创建hashMap、插入hashMap、查找hashMap、删除hashMap，已经若干经典的hash函数。文章链接：https://blog.csdn.net/sxf1061700625/article/details/109594495
java【模拟MAP的底层实现】
极客蓝天
10-27 1188
1.1数组我们无论是C、Java都会学过： 数组是一种连续存储线性结构，元素类型相同，大小相等 数组的优点： 存取速度快 数组的缺点： 事先必须知道数组的长度 插入删除元素很慢 空间通常是有限制的 需要大块连续的内存块 插入删除元素的效率很低 2.1链表说明 看完了数组，回到我们的链表： 链表是离散存储线性结构 n个节点离散分配，彼此通过指针相连，每个节点只有一个前驱节点，每个节点只有一个后...
java学习：java容器——Map接口（代码模拟HashMap的底层实现）
weixin_42924812的博客
03-27 360
java容器——Map接口 1、概念 （1）Map提供了一种映射关系，其中的元素是以键值对（key-value）的形式存储；Map中的键值对以Entry类型的对象实例形式存在； （2）key值不可重复，value值可以重复。一个value值可以和很多key值形成对应关系，每个key值最多只能映射到一个值。 Map接口的实现类有：HashMap、TreeMap、WeakHashMap、HashTab...
Java实现简易HashMap
Juily家的小蜜果
01-27 2805
创建节点类 节点类含有的属性：键值对（value，key）以及指向下一节点的next； 这些属性的get以及set方法 代码如下： /** * 节点类 * @author HP * */ public class Node { private Object value; private Object key; private Node next; /** * 空节点 *...
ThreadLocal源码分析
qq_29860591的博客
04-02 806
1. ThreadLocal的内部结构 1.1 常见的误解 通常，如果我们不去看源代码的话，我猜ThreadLocal是这样子设计的：每个ThreadLocal类都创建一个Map，然后用线程的ID threadID作为Map的key，要存储的局部变量作为Map的value，这样就能达到各个线程的局部变量隔离的效果。这是最简单的设计方法，JDK最早期的ThreadLocal就是这样设计...
hashMap伪代码
小黄宝宝的专栏
01-22 4203
hashMap原理的伪代码 V put(K k , V v) { int hashCode = hashCode(k); Node node = new Node(k, v); if (table[hashCode] == null) { table[hashCode] = node; } else { Node firstNode = table[hashC...
Java实现HashMap
有没有料，进来看看就知道！
05-23 1048
1.HashMap的介绍 HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。 HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。 HashMap 是无序的，即不会记录插入的顺序。 HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。 HashMap 的 key 与 value 类型可以相同也可以不
Java手写一个简单的HashMap
TheCalm的博客
08-19 1864
1.背景介绍 HashMap在Java中是常用的数据结构之一。HashMap 是一个散列表，它存储的内容是键值对(key-value)映射，并具有很快的访问速度。在JDK1.7中，HashMap是基于“数组+链表”实现的，而在JDK1.8以后，HashMap在底层实现中加入了红黑树用于提升查找速率。 图源网络，侵删 在JDK1.8中，当链表的长度大于阈值8时，这时这个链表将会转化成红黑树以提升查找效率。为什么阈值是8呢？请读者不妨思考一下这个问题，在文章末尾笔者将给出原因。（提示：想一想在红黑树和链表中
服务器虚拟化
最新发布
Hellc007的博客
10-30 468
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 961
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
HashMap插入数据时的思路
07-15
在 HashMap 中插入数据时，主要的思路是通过计算键的哈希值来确定数据在内部数组的索引位置，然后将数据存储在该位置上。下面是一般的插入数据的思路： 1. 计算键的哈希值：HashMap 使用键的哈希值来确定数据在内部...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值