Java手写HashMap

之前面试拼多多的时候问到了，但是没练习过。
直接上代码

import java.util.Objects;

/**
 * ClassName: MyHashMap
 * PackageName: com.joshua
 * @author: Joshua Lee
 * @create: 2024/6/10 - 20:21
 * @description: 自己实现HashMap
 */
public class MyHashMap<K, V> {
    static class Node<K, V> {
        private K key;
        private V value;

        private Node<K, V> next;

        // 注意：构造方法中，Node后面不用跟 <K,V>、里面也要用this给指定的属性赋值
        public Node(K key, V value) {
            this.key = key;
            this.value = value;
        }

        // 注意：构造方法中，Node后面不用跟 <K,V>、里面也要用this给指定的属性赋值
        public Node(K key, V value, Node<K, V> next) {
            this.key = key;
            this.value = value;
            this.next = next;
        }
    }

    // 默认容量
    final int DEFAULT_CAPACITY = 16;
    // 默认装载因子
    final float LOAD_FACTOR = .75f;
    // 已经放入map中的元素个数
    private int size;
    // 底层存放数据的数据结构。创建数组时，是有 <K, V>[] 的
    private Node<K, V>[] buckets;

    /**
     * 创建map的无参构造方法。
     */
    public MyHashMap() {
        buckets = new Node[DEFAULT_CAPACITY];
        size = 0;
    }

    /**
     * 创建指定容量的map
     * @param capacity 指定的容量
     */
    public MyHashMap(int capacity) {
        buckets = new Node[capacity];
        size = 0;
    }

    /**
     * 获得当前键key在长度为length的Node数组中的索引下标
     * @param key 当前键
     * @param length 当前底层数组长度
     */
    int getIndex(K key, int length) {
        int hashCode = key.hashCode();
        int index = hashCode % length;
        return Math.abs(index);
    }

    /**
     * 往map中放置数据
     * @param key 想放置的key
     * @param value 想放置的value
     */
    public void put(K key, V value) {
        // 检查是否需要扩容，需要扩容则扩容
        if (size >= buckets.length * LOAD_FACTOR) {
            resize();
        }

        // 将数据放到数组中
        putVal(key, value, buckets);
    }

    /**
     * 将key、value键值对放入Node数组 table中
     * @param key 想放置的key
     * @param value 想放置的value
     * @param table 当前的底层Node数组
     */
    private void putVal(K key, V value, Node<K, V>[] table) {
        // 获得当前key在buckets中的index
        int index = getIndex(key, table.length);
        Node<K, V> node = table[index];

        // 如果当前该位置还没有数据
        if (node == null) {
            table[index] = new Node<>(key, value);
            // 成功将一个元素放到底层数组中，就将size+1
            size++;
            return;
        }
        // 如果当前数组的index位置上已经有数据了
        // 就遍历整条链表，看看是否存在key为要放置的key的结点，如果存在，则覆盖掉原来结点的value
        while (node != null) {
            if (node.key == key || Objects.equals(node.key, key)) {
                node.value = value;
                return;
            }
            node = node.next;
        }

        // 至此，index处的链表里面没有key为传入的key的结点，就使用头插法，将当前的key、value、index处的结点引用封装到Node结点中
        table[index] = new Node<>(key, value, table[index]);
        // 成功将一个元素放到底层数组中，就将size+1
        size++;
    }

    /**
     * 进行底层数组扩容
     */
    private void resize() {
        Node<K, V>[] newBuckets = new Node[buckets.length * 2];
        rehash(newBuckets);
        buckets = newBuckets;
    }

    /**
     * 将原始数组buckets中的每个位置的结点、链表重新hash，放到新的数组newBuckets中
     * @param newBuckets 新的放Node节点的底层数组
     */
    private void rehash(Node<K, V>[] newBuckets) {
        // 当前map的size要归0，因为在调用putVal()中，会执行size++
        size = 0;
        for (int i = 0; i < buckets.length; i++) {
            Node<K, V> node = buckets[i];
            if (node == null) {
                continue;
            }
            while (node != null) {
                putVal(node.key, node.value, newBuckets);
                node = node.next;
            }
        }
    }

    /**
     * 从当前map中获取key对应的value
     * @param key 要查找的key
     * @return key对应的value。如果key不存在，则返回null
     */
    public V get(K key) {
        int index = getIndex(key, buckets.length);
        Node<K, V> node = buckets[index];
        if (node == null) {
            return null;
        }

        while (node != null) {
            if (node.key == key || Objects.equals(node.key, key)) {
                return node.value;
            }
            node = node.next;
        }
        return null;
    }

    /**
     * 获取当前map中有多少个元素
     */
    public int size() {
        return this.size;
    }

    public static void main(String[] args) {
        MyHashMap<String, Integer> map = new MyHashMap<>();
        map.put("abc", 10);
        map.put("def", 20);
        System.out.println(map.get("abc"));
        System.out.println(map.get("de"));
        System.out.println(map.get("def"));
        System.out.println(map.size());
    }
}

注意点

静态内部类Node

key、value是泛型类型，当然面试时，可能就直接指定一个类型就可以了。
由三个属性：key、value、next，再加两个Node的构造方法

MyHash

属性：默认大小：DEFAULT_CAPACITY、装载因子：LOAD_FACTOR、已装入的Node节点个数：size、底层放Node节点的NodeNode<K, V>[] 数组：buckets
方法：构造方法、获取key对应的索引的方法：getIndex()，放置数据的方法：put()、putVal()，扩容的 方法：resize()、rehash()，获取key对应的value的方法：get()，获取数据个数的方法：size()。

因为底层数组是泛型，所以，有几处写法需要注意

定义buckets成员时：private Node<K, V>[] buckets; 有 <K, V> 。
给buckets赋值时：buckets = new Node[capacity]; 没有 <K, V> 。

定义Node节点时：Node<K, V> node = new Node<>(key, value);