与众不同：HashMap 核心源码解析

Android

2024-02-11 13:30:31

HashMap的核心原理

HashMap的核心原理是使用哈希表来存储数据。哈希表是一种数据结构，它将数据存储在数组中，并且使用哈希函数来将键映射到数组中的索引。这样，就可以通过键快速地找到对应的值。

HashMap的哈希函数是通过键的hashCode()方法来计算的。hashCode()方法会将键转换为一个整数，然后使用这个整数来计算键在数组中的索引。

HashMap的核心实现

HashMap的核心实现包括以下几个方面：

哈希表：HashMap使用数组来存储数据，并且使用哈希函数来将键映射到数组中的索引。
哈希函数：HashMap的哈希函数是通过键的hashCode()方法来计算的。hashCode()方法会将键转换为一个整数，然后使用这个整数来计算键在数组中的索引。
链表：HashMap中使用链表来存储键值对。当两个键的哈希值相同时，它们会被存储在同一个链表中。
红黑树：在Java 8中，HashMap使用红黑树来存储键值对。红黑树是一种自平衡二叉树，它可以保证键值对的存储顺序是按照键的比较结果来排列的。

手写HashMap核心源码

我们现在来手写HashMap的核心源码。首先，我们需要定义一个HashMap类，如下所示：

public class HashMap<K, V> {

    private int size; // 哈希表的大小
    private Node<K, V>[] table; // 哈希表

    public HashMap() {
        this(16); // 默认哈希表的大小为16
    }

    public HashMap(int size) {
        this.size = size;
        table = new Node[size];
    }

    public void put(K key, V value) {
        // 计算键的哈希值
        int hash = key.hashCode();
        // 计算键在哈希表中的索引
        int index = hash % size;
        // 如果索引处的链表为空，则创建一个新的链表
        if (table[index] == null) {
            table[index] = new Node<>(key, value);
        } else {
            // 如果索引处的链表不为空，则将键值对添加到链表中
            Node<K, V> node = table[index];
            while (node != null) {
                if (node.key.equals(key)) {
                    node.value = value;
                    return;
                }
                node = node.next;
            }
            table[index].add(key, value);
        }
    }

    public V get(K key) {
        // 计算键的哈希值
        int hash = key.hashCode();
        // 计算键在哈希表中的索引
        int index = hash % size;
        // 如果索引处的链表为空，则返回null
        if (table[index] == null) {
            return null;
        } else {
            // 如果索引处的链表不为空，则遍历链表找到键值对
            Node<K, V> node = table[index];
            while (node != null) {
                if (node.key.equals(key)) {
                    return node.value;
                }
                node = node.next;
            }
            return null;
        }
    }

    public void remove(K key) {
        // 计算键的哈希值
        int hash = key.hashCode();
        // 计算键在哈希表中的索引
        int index = hash % size;
        // 如果索引处的链表为空，则返回
        if (table[index] == null) {
            return;
        } else {
            // 如果索引处的链表不为空，则遍历链表删除键值对
            Node<K, V> node = table[index];
            Node<K, V> prev = null;
            while (node != null) {
                if (node.key.equals(key)) {
                    if (prev == null) {
                        table[index] = node.next;
                    } else {
                        prev.next = node.next;
                    }
                    return;
                }
                prev = node;
                node = node.next;
            }
        }
    }

    private static class Node<K, V> {

        private K key;
        private V value;
        private Node<K, V> next;

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

        public void add(K key, V value) {
            if (next == null) {
                next = new Node<>(key, value);
            } else {
                next.add(key, value);
            }
        }
    }
}