【Java】面试代码题 手写 HashMap（参考 JDK7 拉链头插法实现）

已于 2022-06-02 20:59:45 修改
阅读量742 收藏 2
点赞数
分类专栏： 总结 知识 文章标签： java 面试 HashMap
于 2022-06-02 20:11:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Krone_/article/details/125053241
版权

这是一个参考 JDK7 实现的非常简单的 HashMap，只实现了最最基础的 get、put、remove、containsKey 方法。解决冲突用的是最简单的拉链法，hash 用的是 JDK 自带的 hashCode() 提供的值。这份代码主要面向面试时的手撕 HashMap，本文会逐一介绍每个部分的实现，最后会在文末给出所有代码。

关于头插和尾插的问题我是这么考虑的：
选用和 JDK 7 一样的头插，不考虑并发下头插成环问题，因为我觉得并发修改必然就得加锁，没有必要考虑并发下的一些问题，至于加锁后效率那是加锁需要考虑的问题。并且假设刚 put 的元素，最有可能马上 get，所以选用效率可能较高的头插。

CONTENT

接口

在 MyMap 接口中定义了要实现的方法，本次只准备实现 5 个基础方法，get、put、remove、containsKey 和 自创的 entryList（就是把所有 Entry 放进一个 List，只是为了方便打印全部元素看看效果）。

MyMap.Entry 接口定义了 MyHashMap 中存放的每个元素 Entry 将提供的方法。

public interface MyMap<K, V> {
    V get(K key);
    V put(K key, V value);
    V remove(K key);
    boolean containsKey(K key);
    List<MyHashMap.Entry<K, V>> entryList();
    interface Entry<K, V> {
        K getKey();
        V getValue();
        void setKey(K key);
        void setValue(V value);
    }
}

Entry

MyHashMap 中每个元素对象的类，正常的 key-value 键值对，因为拉链法，加上 next 指向下一个 Entry。

static class Entry<K, V> implements MyMap.Entry<K, V> {

    K key;
    V value;
    Entry<K, V> next;

    public Entry(K key, V value, Entry<K, V> next) {
        this.key = key;
        this.value = value;
        this.next = next;
    }

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }

    @Override
    public void setKey(K key) {
        this.key = key;
    }

    @Override
    public void setValue(V value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Entry{" +
                "key=" + key +
                ", value=" + value +
                ", next=" + next +
                '}';
    }
}

全局变量 & 构造方法

loadFactor 是负载因子，默认为 0.75，当存储元素数量超过 capacity*loadFactor 时，进行扩容。
threshold = capacity*loadFactor，当 size >= threshold 时扩容。
size 是当前存储的 Entry 元素的数量。
table 数组用来存储 Entry 元素。

提供三个构造方法，初始化时，以及之后的扩容，保证 table 的 length 一定是 2 的次幂。

为什么 HashMap 的大小为什么必须是 2 的倍数？

  1. 利用 hash 值计算索引时，如果用取余 hash%length 效率较低，并且当 length 是 2 的倍数时，hash&(length-1) 和 取余的结果是一样的，但位运算比取余的效率高得多。
  2. length 是 2 的倍数，扩容时可以直接看 hash&oldLength 是不是等于 0，如果等于 0，那这个元素继续呆在原来的位置（比如说 j），如果不等于 0，那么这个元素放到新扩容出来的 j+oldLength 的位置，这和重新计算索引的结果是一样。但这样减少了对于每个元素都重新计算它的索引的开销。（JDK8 的实现）
class MyHashMap<K, V> implements MyMap<K, V> {

    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;
    private final float loadFactor;
    private int threshold;
    private int size;
    private Entry<K, V>[] table;

    public MyHashMap(int initCapacity, float loadFactor) {
        int capacity = 1;
        while (capacity < initCapacity)
            capacity <<= 1;
        this.loadFactor = loadFactor;
        table = new Entry[capacity];
        threshold = (int) (capacity*loadFactor);
        size = 0;
    }

    public MyHashMap(int initCapacity) {
        this(initCapacity, DEFAULT_LOAD_FACTOR);
    }

    public MyHashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }
}

get & containsKey

这两个其实可以做成一个实现，因为他们本质上都是要找某一个 key 所属的 Entry，只不过 get 要求返回 key 所属的 Entry 中的 value，而 containsKey 只想知道这个 key 所属的 Entry 是否存在。所以完全可以实现一个 getEntry() 方法，返回 key 所属的 Entry。这样 get() 就是返回 getEntry() 找到的 Entry 中的 value，而 containsKey 则是判断 getEntry() 能否找到对应的 Entry。

getEntry() 先得到 key 对应 table 中的索引下标，拿到 table 下标处链表的头节点，遍历链表，用 key 做比较，如果找到直接返回当前 entry，找不到则返回 null。

@Override
public V get(K key) {
    Entry<K, V> entry = getEntry(key);
    return entry == null ? null : entry.getValue();
}

private Entry<K, V> getEntry(K key) {
    int index = getKeyIndex(key);
    for (Entry<K, V> entry = table[index]; entry != null; entry = entry.next) {
        if (entry.getKey() == key || entry.getKey().equals(key)) {
            return entry;
        }
    }
    return null;
}

private int getKeyIndex(K key) {
    return key == null ? 0 : (key.hashCode() & (table.length-1));
}

@Override
public boolean containsKey(K key) {
    return getEntry(key) != null;
}

put

这算是这里面最难的了，因为涉及到扩容 resize()。

put 思路比较简单，先得到 key 对应 table 中的索引下标，拿到 table 下标处链表的头节点，遍历链表，用 key 做比较，看有没有和 key 一样的 Entry，如果有，直接更新这个 Entry 的 value 并返回原来的 value （这部分 和 getEntry() 的逻辑一样）。如果 table 中没有这个 key，说明需要新建一个 Entry 存储这个 key-value 对。但在新建 Entry 前，先检查是否需要扩容，即 size >= threshold。然后新建一个 Entry 并头插到原来的链表里，并把新的链表头更新到 table[index] 中。

@Override
public V put(K key, V value) {
    int index = getKeyIndex(key);
    // 找有没有 key 一样的
    for (Entry<K, V> entry = table[index]; entry != null; entry = entry.next) {
        if (entry.getKey() == key || entry.getKey().equals(key)) {
            V oldValue = entry.getValue();
            entry.setValue(value);
            return oldValue;
        }
    }
    // 没有一样的 key 只能新建一个 Entry
    // 新建之前先检查是否需要扩容
    if (size >= threshold) {
        resize(table.length*2);
        index = getKeyIndex(key); // 因为扩容了，原来的索引不一定对
    }
    table[index] = new Entry<>(key, value, table[index]);
    size++;
    return value;
}

private int getKeyIndex(K key) {
    return key == null ? 0 : (key.hashCode() & (table.length-1));
}

扩容

resize() 新建一个是原来 table 长度二倍的 table，并将原来 table 的元素迁移到新建的 table 中去。最后更新 threshold = newCapacity*loadFactor。

这里迁移做的比较简单：遍历一遍原来的 table，在遍历的同时，计算每个元素在新的 table 中的索引下标，然后把它头插到新 table 中对应的索引下标的链表中去，并把新的链表头更新到新的 table[index] 中。

private void resize(int newCapacity) {
    Entry<K, V>[] oldTable = table;
    table = new Entry[newCapacity];
    for (Entry<K, V> entry : oldTable) {
        while (entry != null) {
            Entry<K, V> next = entry.next;
            int index = getKeyIndex(entry.getKey());
            entry.next = table[index];
            table[index] = entry;
            entry = next;
        }
    }
    threshold = (int) (newCapacity*loadFactor);
}

remove

看过前面的 get、put 之后，remove 相比之下就非常简单了。计算得到 key 对应 table 中的索引下标，拿到 table 下标处链表的头节点，遍历链表，并记录当前节点的前一个节点 pre，然后用 key 做比较，看有没有和 key 一样的 Entry，如果有，用 pre 节点指向当前节点的 next，做一个链表删除操作即可。

@Override
public V remove(K key) {
    int index = getKeyIndex(key);
    Entry<K, V> entry = table[index];
    Entry<K, V> pre = null;
    while (entry != null) {
        if (entry.getKey() == key || entry.getKey().equals(key)) {
            if (pre != null) {
                pre.next = entry.next;
            } else {
                table[index] = entry.next;
            }
            return entry.getValue();
        }
        pre = entry;
        entry = entry.next;
    }
    return null;
}

private int getKeyIndex(K key) {
    return key == null ? 0 : (key.hashCode() & (table.length-1));
}

entryList

entryList 非常简单，遍历一遍 table，把每个 Entry 添加到结果 List 中即可。这个方法只是为了方便打印全部元素看看效果。

@Override
public List<Entry<K, V>> entryList() {
    List<Entry<K, V>> res = new ArrayList<>();
    for (Entry<K, V> entry : table) {
        while (entry != null) {
            res.add(entry);
            entry = entry.next;
        }
    }
    return res;
}

全部代码

接口 MyMap

import java.util.List;

public interface MyMap<K, V> {
    V get(K key);
    V put(K key, V value);
    V remove(K key);
    boolean containsKey(K key);
    List<MyHashMap.Entry<K, V>> entryList();
    interface Entry<K, V> {
        K getKey();
        V getValue();
        void setKey(K key);
        void setValue(V value);
    }
}

实现类 MyHashMap

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

class MyHashMap<K, V> implements MyMap<K, V> {

    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;
    private final float loadFactor;
    private int threshold;
    private int size;
    private Entry<K, V>[] table;

    public MyHashMap(int initCapacity, float loadFactor) {
        int capacity = 1;
        while (capacity < initCapacity)
            capacity <<= 1;
        this.loadFactor = loadFactor;
        table = new Entry[capacity];
        threshold = (int) (capacity*loadFactor);
        size = 0;
    }

    public MyHashMap(int initCapacity) {
        this(initCapacity, DEFAULT_LOAD_FACTOR);
    }

    public MyHashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

    @Override
    public V get(K key) {
        Entry<K, V> entry = getEntry(key);
        return entry == null ? null : entry.getValue();
    }

    private Entry<K, V> getEntry(K key) {
        int index = getKeyIndex(key);
        for (Entry<K, V> entry = table[index]; entry != null; entry = entry.next) {
            if (entry.getKey() == key || entry.getKey().equals(key)) {
                return entry;
            }
        }
        return null;
    }

    private int getKeyIndex(K key) {
        return key == null ? 0 : (key.hashCode() & (table.length-1));
    }

    @Override
    public V put(K key, V value) {
        int index = getKeyIndex(key);
        // 找有没有 key 一样的
        for (Entry<K, V> entry = table[index]; entry != null; entry = entry.next) {
            if (entry.getKey() == key || entry.getKey().equals(key)) {
                V oldValue = entry.getValue();
                entry.setValue(value);
                return oldValue;
            }
        }
        // 没有一样的 key 只能新建一个 Entry
        // 新建之前先检查是否需要扩容
        if (size >= threshold) {
            resize(table.length*2);
            index = getKeyIndex(key); // 因为扩容了，原来的索引不一定对
        }
        table[index] = new Entry<>(key, value, table[index]);
        size++;
        return value;
    }

    private void resize(int newCapacity) {
        Entry<K, V>[] oldTable = table;
        table = new Entry[newCapacity];
        for (Entry<K, V> entry : oldTable) {
            while (entry != null) {
                Entry<K, V> next = entry.next;
                int index = getKeyIndex(entry.getKey());
                entry.next = table[index];
                table[index] = entry;
                entry = next;
            }
        }
        threshold = (int) (newCapacity*loadFactor);
    }

    @Override
    public V remove(K key) {
        int index = getKeyIndex(key);
        Entry<K, V> entry = table[index];
        Entry<K, V> pre = null;
        while (entry != null) {
            if (entry.getKey() == key || entry.getKey().equals(key)) {
                if (pre != null) {
                    pre.next = entry.next;
                } else {
                    table[index] = entry.next;
                }
                return entry.getValue();
            }
            pre = entry;
            entry = entry.next;
        }
        return null;
    }

    @Override
    public boolean containsKey(K key) {
        return getEntry(key) != null;
    }

    @Override
    public List<Entry<K, V>> entryList() {
        List<Entry<K, V>> res = new ArrayList<>();
        for (Entry<K, V> entry : table) {
            while (entry != null) {
                res.add(entry);
                entry = entry.next;
            }
        }
        return res;
    }

    static class Entry<K, V> implements MyMap.Entry<K, V> {

        K key;
        V value;
        Entry<K, V> next;

        public Entry(K key, V value, Entry<K, V> next) {
            this.key = key;
            this.value = value;
            this.next = next;
        }

        @Override
        public K getKey() {
            return key;
        }

        @Override
        public V getValue() {
            return value;
        }

        @Override
        public void setKey(K key) {
            this.key = key;
        }

        @Override
        public void setValue(V value) {
            this.value = value;
        }

        @Override
        public String toString() {
            return "Entry{" +
                    "key=" + key +
                    ", value=" + value +
                    ", next=" + next +
                    '}';
        }
    }
}

Reference

  1. leishen6.github.io：木子雷的博客：面试手写HashMap，手撕HashMap
  2. JDK7源码：OpenJDK™ Source Releases：src\share\classes\java\util
  3. JDK8源码：OpenJDK™ Source Releases：src\share\classes\java\util
  4. CSDN：OnlyloveCuracao：HashMap的大小为什么必须是2的倍数
  5. CSDN：猿人小郑：HashMap初始容量为什么是2的n次幂及扩容为什么是2倍的形式
KroneX
关注
专栏目录
BAT 大厂Java 面试题集锦之核心篇附参考答案
AI天才研究院
11-05 1万+
核心篇数据结构与算法网路:TCP/IP,HTTP操作系统, 文件, shell, CPU, IO, epoll, 非阻塞IO,进程/线程/协程,锁HashMap, Co...
Java手写一个简单的HashMap
TheCalm的博客
08-19 1878
1.背景介绍 HashMap在Java中是常用的数据结构之一。HashMap 是一个散列表，它存储的内容是键值对(key-value)映射，并具有很快的访问速度。在JDK1.7中，HashMap是基于“数组+链表”实现的，而在JDK1.8以后，HashMap在底层实现中加入了红黑树用于提升查找速率。 图源网络，侵删 在JDK1.8中，当链表的长度大于阈值8时，这时这个链表将会转化成红黑树以提升查找效率。为什么阈值是8呢？请读者不妨思考一下这个问题，在文章末尾笔者将给出原因。（提示：想一想在红黑树和链表中
对HashMap的思考及手写实现
qq_35873960的博客
08-02 1096
前言HashMap是Java中常用的集合，而且HashMap的一些思想，对于我们平时解决业务上的一些问题，在思路上有帮助，基于此，本篇博客将分析HashMap底层设计思想，并手写一个迷你版的HashMap！对HashMap的思考HashMap底层数据结构 第一，如图所示，HashMap有3个要素：hash函数+数组+单链表第二，对于hash函数而言，需要考虑些什么？要快，对于给定的Key，要能够...
Java面试手写代码题
m0_67393827的博客
04-04 595
1、栈实现 2、Iterator实现 3、单例 4、多线和控制（暂停，恢复，停止） 5、生产者消费者 转载于:https://www.cnblogs.com/mzzcy/p/7004409.html
mysql 无论输入什么都是现实 not found_Java高频面试题及答案
weixin_39716044的博客
02-18 122
2.1 冒泡排序(Bubble Sort)算法描述：(从小到大排序)● 比较相邻的元素。如果第一个比第二个大，就交换它们两个；● 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；● 针对所有的元素重复以上的步骤，除了最后一个；● 重复步骤1~3，直到排序完成。如果两个元素相等，不会再交换位置，所以冒泡排序是一种稳定排序算法。代码实现：package a...
java面笔试_java笔试手写算法面试题大全含答案
weixin_31659795的博客
02-12 203
java笔试手写算法面试题大全含答案1.统计一篇英文文章单词个数。public class WordCounting {public static void main(String[] args) {try(FileReader fr = new FileReader("a.txt")) {int counter = 0;boolean state = false;int currentChar;...
手写一个HashMap（附demo，有注释，复制就能跑）
秃头计划——启动！
01-05 1312
手写HashMap，你上你也行！
Java常见面试题
ConSelt的博客
01-08 417
基础面试题(不定时更新)
学习JDK7 HashMap添加源码写的链表头插法案例
KevinLoveJava
01-28 695
参考学习网站: www.mayikt.com hashMap在发生hashcode冲突的时候，在数组中使用链表，并且冲突的元素添加到链表头,简称 头插法。 package com.mayikt.linkedlist; /** * 单向链表 * * @author zx * @date 2022年01月28日 16:10 */ public class SingleLinkedList<T> { /** * 头结点 */ transient .
Java工程师面试题
m0_46152493的博客
04-09 1022
前言 我相信都是这个世界上的“有心人”，还是那句话：时间不负有心人，星光不问赶路人； 适宜阅读人群 准备跳槽的初/中/高级 Java 程序员 想要查漏补缺的人 想要不断完善和扩充自己 Java 技术栈的人 Java 面试官 一、Java基础 1.JDK和JRE的区别 JDK：Java开发工具包；提供Java的开发环境和运行环境。 JRE：Java运行环境；提供Java运行所需要的运行环境。 2.==和equals的区别 ==解读：基本类型比较值，引用类型比较内存地址 equal...
java小白翻身-手写HashMap
java小白翻身
09-27 775
什么是HashMap 这一节课，我们来手写一个简单的HashMap，所谓HashMap，就是一个映射表。 比如现在我有一个客户类，就用之前的就好。 现在我有100个客户，名字各不相同，有叫张三的，也有叫李四的，还有的人叫张全蛋。如果现在要你从这100个人中找到一个叫做王尼玛的人，你怎么办？ 这好像很简单，我们不是刚刚做了一个TuziLinkedList吗？一个个add进去，数据初始化，然后再用foreach去遍历不就行了？可是，这样的效率是很低的，假如王尼玛正好在链表的最后一个，那就需要遍历100次才能找
银行java面试题手写代码_面试系列——手写代码实现（一）
weixin_32184991的博客
02-25 648
前言本文是面试系列篇的实现篇。笔者整理了面试过程中可能会遇到的手写实现，以及它的原理。这可以帮助面试者在笔试环节获得良好的加分。其他文章系列，欢迎关注我文末的公众号正文apply和callapply和call的实现中，主要是利用了两个点：根据传入的thisArgs去创建对象在新创建的对象上定义当前函数，然后进行调用apply和call的区别：apply在指定对象后只接受一个参数call在指定对象后...
【面试题之】：手撕HashMap
CAFE-BABE的博客
07-21 864
前几天字节二面，面试官要求自己手写一个HashMap，当时就有些被惊到了，虽然读过HashMap的源码，也能侃侃而谈，但是说的和做的难度还是不一样的，当时吹了一会HashMap之后，面试官淡淡一笑，说：“好的，那写一下吧，，，，”。看来还是逃不过啊，最后写的不太好，所以说，大家以后还是要动起手来啊！ 首先HashMap的底层就是一个数组，数组里面保存了Key和Value，以及一个next指针，如果没有哈希冲突的话，next指针就是null，如果有哈希冲突，那么就会形成链表，指向下一个元素。这里我们首先要了
java手写_java面试：手写代码
weixin_39623082的博客
02-12 396
二分查找法。/*** 二分查找法：给定一组有序的数组，每次都从一半中查找。直到找到要求的数据。* 主要是得找到下标的表示方法。*/public class BinaryFind {/*** 使用二分法，找到有序数组中的某个数，返回下标。* @param sortedArray* @param number* @return*/public int find(int[] sortedArra...
【学习笔记】JDK源码学习之HashMap（附带面试题）
小宝的博客
12-20 564
自律即自由！
（2021）Java架构师面试题汇总
知识改变命运，ヾ(◍°∇°◍)ﾉﾞ【求关注】
08-20 2266
面试题汇总，答案继续中
手写HashMap，快手面试官直呼内行
热门推荐
三分恶的博客
11-23 2万+
快手一面，手写HashMap,卒……
[Java 代码] 面试前整理，针对手写代码
最新发布
key_honghao的博客
08-07 486
文章围绕着手写代码这一关键环节展开，涵盖了多个重要主题，如集合、排序算法、字符串处理等。通过系统性的整理和归纳，文章为读者提供了面试过程中可能涉及到的常见问题和解决方案，帮助读者理清面试需要关注的重点。此外，文章以清晰简明的方式展示了每个主题的基本概念和示例代码，使读者能够更好地理解和应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值