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

已于 2022-06-02 20:59:45 修改
阅读量441 收藏 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
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java手写一个简单的HashMap
TheCalm的博客
08-19 1749
1.背景介绍 HashMap在Java中是常用的数据结构之一。HashMap 是一个散列表，它存储的内容是键值对(key-value)映射，并具有很快的访问速度。在JDK1.7中，HashMap是基于“数组+链表”实现的，而在JDK1.8以后，HashMap在底层实现中加入了红黑树用于提升查找速率。 图源网络，侵删 在JDK1.8中，当链表的长度大于阈值8时，这时这个链表将会转化成红黑树以提升查找效率。为什么阈值是8呢？请读者不妨思考一下这个问题，在文章末尾笔者将给出原因。（提示：想一想在红黑树和链表中
JAVA--HashMap热门面试题
08-19
JAVA--HashMap热门面试题 HashMap 是 Java 中一个常用的集合框架，特别是在面试中，它是最常被问到的问题之一。在这里，我们将讨论一些热门的 HashMap 面试题，以帮助您更好地理解 HashMap 的工作原理和应用。 为...
HashMap详解
weixin_50032318的博客
02-29 1168
HashMap内部的bucket数组长度为什么一直都是2的整数次幂答：这样做有两个好处，第一，可以通过(table.length - 1) & key.hash()这样的位运算快速寻址，第二，在HashMap扩容的时候可以保证同一个桶中的元素均匀地散列到新的桶中，具体一点就是同一个桶中的元素在扩容后一般留在原先的桶中，一般放到了新的桶中。HashMap默认的bucket数组是多大答：默认是16，即时指定的大小不是2的整数次幂，HashMap也会找到一个最近的2的整数次幂来初始化桶数组。
java怎么手写hashmap实现
weixin_35753291的博客
01-03 251
可以通过使用数组来手写 HashMap 的实现。每个数组项可以包含一个键值对。当想要添加一个键值对时，可以使用哈希函数将键转换为数组索引，并将值存储在该索引处。当想要检索与特定键关联的值时，可以使用哈希函数计算键的数组索引，并检索该索引处的值。 下面是一个示例实现： class HashMap { private static class Entry { private final O...
最新Java手写Hashmap(HashMap的基本用法)，含小米、腾讯、阿里
最新发布
2401_84007015的博客
05-14 649
这些面试题是我朋友进阿里前狂刷七遍以上的面试资料，由于面试文档很多，内容更多，没有办法一一为大家展示出来，所以只好为大家节选出来了一部分供大家参考。//只是位运算 效率高 其效果与取模运算一样（v%(length - 1)）面试的本质不是考试，而是告诉面试官你会做什么，所以，这些面试资料中提到的技术也是要学会的，不然稍微改动一下你就凉凉了。//如果新节点的键值 等于 该该链表当中的数据 则覆盖。//此处数组元素为空，则直接将新节点放进去。//此处数组元素不为空，则遍历对应的链表。
手写HashMap，快手面试官直呼内行
热门推荐
三分恶的博客
11-23 2万+
快手一面，手写HashMap,卒……
java代码-使用java解决手写hashMap的源代码
03-20
java代码-使用java解决手写hashMap的源代码 ——学习参考资料：仅用于个人学习使用！
在Java8与Java7中HashMap源码实现的对比
08-31
本篇文章将深入对比Java 7和Java 8中HashMap的源码实现，探讨它们在解决哈希冲突和优化性能上的差异。 一、HashMap的基本原理 HashMap基于哈希表实现，它使用键的哈希值来决定键值对在数组中的位置。哈希表通过计算...
面试题之详解HashMap
12-21
在JDK 1.7中，resize过程中使用了头插法，这在并发时可能使链表反转，导致get操作陷入死循环。而从JDK 1.8开始，resize时采用了尾插法，虽然避免了链表反转，但并发环境下仍推荐使用线程安全的`ConcurrentHashMap`。...
Java集合框架常见面试题.7z
12-03
以下是一些关于Java集合框架的常见面试题及对应的详细解释： 1. **什么是集合框架？** 集合框架是一系列接口和类的集合，它们提供了在Java中处理对象集合的统一方式。这些接口和类包括List、Set、Map等，以及它们...
面试题手写代码（很实用）
04-20
这是我面试了十三家所总结的手写代码题，希望能帮助您！
手写简易版HashMap
Dream_it_possible！的博客
05-16 2445
前言 我们发现HashMap在jdk 1.8之后用了数组+链表+红黑树的结构，为了加深对HashMap底层设计的理解，自己也读了一些hashmap相关的源码，因此想通过手写hashmap去理其底层的操作原理。 HashMap源码解析 目标: 基于数组+链表结构实现一个HashMap，包含get()、put()、remove()方法。 环境: jdk1.8 知识储备: hashcode, 幂等性， 数组，链表，红黑树。 原理: Hash...
Java笔试手写算法面试题大全含答案
编程领域的博客
10-26 1407
先给大家复习一下基础题！！！ Java基础是java初学者的起点，是帮助你从小白入门到精通必学基础课程！ 为初学者而著！ Java300集>>>适合准备入行开发的零基础员学习Java，基于最新JDK13、IDEA平台讲解的，视频中穿插多个实战项目。每一个知识点都讲解的通俗易懂，由浅入深。不仅适用于零基础的初学者，有经验的程序员也可做巩固学习。 配套学习：Java初学者入门教程>>> 1、统计一篇英文文章单词个数。 public class Wo...
Hashmap的结构，1.7和1.8有哪些区别
weixin_49193222的博客
12-04 1276
不同点： （1）JDK1.7用的是头插法，而JDK1.8及之后使用的都是尾插法，那么他们为什么要这样做呢？因为JDK1.7是用单链表进行的纵向延伸，当采用头插法时会容易出现逆序且环形链表死循环问题。但是在JDK1.8之后是因为加入了红黑树使用尾插法，能够避免出现逆序且链表死循环的问题。 （2）扩容后数据存储位置的计算方式也不一样：1. 在JDK1.7的时候是直接用hash值和需要扩容的二进制数进行&（这里就是为什么扩容的时候为啥一定必须是2的多少次幂的原因所在，因为如果只有2的n次幂的情况...
知识点（4）——HashMap中插入数据用的头插法还是尾插法
u010257931的博客
11-19 1万+
前言 大家都知道，HashMap用到的数据结构，在JDK8之前是数组+单链表。在JDK8用的是数组+单链表+红黑树。 这里说一句题外话，为什么JDK8时候引入了红黑树？ （1）因为当数组中每个元素，都是一个Entry，每一个Entry是一个单链表。 （2）当链表长度过长的时候，查询链表中的一个元素就比较耗时，这时就引入了红黑树。 （3）首先红黑树是一棵二叉树，而且属于二叉树中比较特殊的二...
JDK1.7中HashMap采用头插法扩容时的产生的链表循环问题
茶颜悦色
09-21 1789
在JDK1.7时，HashMap的结构主要为数据＋链表，在扩容时采用头插法，在单线程时表现正常，但在多线程时存在着链表循环的问题，下面对该问题来进行一个分析。 HashMap的容量是有限的，当元素插入一个接近饱和的HashMap之时，则会触发HashMap的扩容机制，也就是Resize。 触发Resize有两个因素 Capacity LoadFactor 即当HashMap.Size >= Capacity * LoadFactor时，便进行Resize操作 Resize的具体操作 扩容 创建
HashMap1.7和1.8头插入与尾插入的原因
weixin_39406672的博客
10-15 7397
头插法是操作速度最快的，找到数组位置就直接找到插入位置了，但是课程里演示过， jdk8之前hashmap这种插入方法在并发场景下如果多个线程同时扩容会出现循环列表。 jdk8开始hashmap链表在节点长度达到8之后会变成红黑树，这样一来在数组后节点长 度不断增加时，遍历一次的次数就会少很多很多（否则每次要遍历所有），相比头插法 而言，尾插法操作额外的遍历消耗已经小很多了，也可以避免之前的循环列表...
解析JDK1.7 HashMap 头插法生成的环形链表死循环问题
是狮不是猿
03-25 5426
背景 在JDK1.7中HashMap使用头插法来添加同一位置上的节点,但是在并发的情况下使用HashMap，在进行resize()扩容的过程中，链表可能会形成环状，当在读取HashMap元素的时候会出现死循环，CPU占用标高，服务器崩溃的问题。 扩容前 正常 resize() 后 并发 resize() 形成环状 在下面我会说明是如何生成该环状 正常扩容resize()的过程 以下执行的过程是在同一链表元素的key值rehash后落到同一坐标上为基础 我们需要关注的是HashMap的resize()方

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值