Java手写实现HashMap

Java手写实现HashMap

当你使用编程语言开发应用程序时，经常需要使用到字典数据结构，来存储键值对。HashMap 是一种常见且高效的字典实现方式。本篇博客将向你展示如何用 Java 手写一个简单的 HashMap，包括具体思路、详细介绍、每个步骤的代码和文字说明
HashMap 是 Java 中常用的数据结构，它基于哈希表实现。它通过将键映射到数组中的位置来存储和检索键值对。

原理：

1. 当插入键值对时，HashMap 首先计算键的哈希码（通过 hashCode() 方法），然后将哈希码映射到数组的索引位置。
2. 如果发生哈希冲突（不同的键映射到了相同的索引位置），则使用链表或红黑树来解决冲突。
3. 在检索时，HashMap 使用相同的哈希函数来计算键的哈希码，然后在对应位置的链表或红黑树中查找键值对。

下面是 Java 手写实现 HashMap 的简化版本代码，用文字绘制图例进行说明：

public class MyHashMap {
    private static final int DEFAULT_CAPACITY = 16; // 默认初始容量
    private Entry[] table; // 哈希表数组

    // 哈希表中的节点
    static class Entry {
        final K key;
        V value;
        Entry next;

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

    public MyHashMap() {
        table = new Entry[DEFAULT_CAPACITY];
    }

    // 计算键的哈希码
    private int hash(K key) {
        return key.hashCode() % table.length;
    }

    // 插入键值对
    public void put(K key, V value) {
        int index = hash(key);
        Entry entry = new Entry<>(key, value, null);

        if (table[index] == null) {
            table[index] = entry;
        } else {
            Entry curr = table[index];
            while (curr.next != null) {
                if (curr.key.equals(key)) {
                    curr.value = value;
                    return;
                }
                curr = curr.next;
            }
            curr.next = entry;
        }
    }

    // 获取键对应的值
    public V get(K key) {
        int index = hash(key);
        Entry curr = table[index];

        while (curr != null) {
            if (curr.key.equals(key)) {
                return curr.value;
            }
            curr = curr.next;
        }
        return null;
    }
}

图例解释：
在图例中，MyHashMap 类代表 HashMap 数据结构，其中：

• Entry 类代表哈希表中的节点，包含键、值以及下一个节点的引用。
• table 数组是 HashMap 的哈希表，用于存储节点。
• put 方法用于插入键值对，首先计算键的哈希码，然后将节点插入到对应位置的链表或红黑树中。
• get 方法用于获取键对应的值，首先计算键的哈希码，然后在对应位置的链表或红黑树中查找键值对。

这是一个简化版本的实现，以下我手写完整的 HashMap 还包含了更多的功能和优化细节，请继续往下浏览：

思路

1. 首先，我们需要确定 HashMap 的基本结构。HashMap 由一个固定大小的数组和哈希函数组成。数组的每个位置称为桶(bucket)，用来存储具有相同哈希值的键值对。
2. 接下来，我们需要实现一个哈希函数，它能够将键映射到数组的索引上。一个好的哈希函数能够尽可能地均匀地分布键值对，以避免冲突。
3. 在桶中存储键值对时，我们需要解决冲突的问题。冲突会发生在两个或多个不同的键具有相同的哈希值时。解决冲突的方式通常有两种：链表法和开放地址法。本篇博客将使用链表法来解决冲突。
4. 最后，我们需要实现 HashMap 的基本操作，包括插入键值对、获取值、删除键值对等。

详细介绍

初始化哈希表

我们将创建一个名为 HashMap 的类，其中包含一个构造函数，用于初始化哈希表。首先，我们定义一个数组 bucket，用来存储桶的信息。在构造函数中，我们可以指定哈希表的大小，例如 size。然后，我们初始化 bucket 数组，并将每个桶都初始化为一个空链表。这样，我们就完成了哈希表的初始化。

public class HashMap<K, V> {
    private LinkedList<Entry<K, V>>[] buckets;
    private int size;
    
    public HashMap(int size) {
        this.size = size;
        buckets = new LinkedList[size];
        for (int i = 0; i < size; i++) {
            buckets[i] = new LinkedList<>();
        }
    }
}

实现哈希函数

每个桶都需要根据键的哈希值来找到合适的位置。我们可以使用 Java 提供的 hashCode 方法来获取键的哈希值，然后使用取余操作将哈希值映射到合适的范围内。在 HashMap 类中，我们可以定义一个私有的函数 hash 来完成这个操作。

private int hash(K key) {
    int hashCode = key.hashCode();
    return hashCode % size;
}

插入键值对

当我们向 HashMap 中插入键值对时，需要执行以下步骤：

1. 根据键的哈希值找到对应的桶。
2. 在该桶中搜索是否存在相同的键。如果存在，更新其对应的值；如果不存在，创建一个新的 Entry 对象，并将其添加到该桶的链表中。

public void put(K key, V value) {
    int index = hash(key);
    LinkedList<Entry<K, V>> bucket = buckets[index];
    
    for (Entry<K, V> entry : bucket) {
        if (entry.getKey().equals(key)) {
            entry.setValue(value);
            return;
        }
    }
    
    Entry<K, V> newEntry = new Entry<>(key, value);
    bucket.add(newEntry);
}

获取值

当我们需要根据键获取值时，需要执行以下步骤：

1. 根据键的哈希值找到对应的桶。
2. 在该桶中搜索是否存在相同的键。如果存在，返回对应的值；如果不存在，返回 null。

public V get(K key) {
    int index = hash(key);
    LinkedList<Entry<K, V>> bucket = buckets[index];
    
    for (Entry<K, V> entry : bucket) {
        if (entry.getKey().equals(key)) {
            return entry.getValue();
        }
    }
    
    return null;
}

删除键值对

当我们需要删除键值对时，需要执行以下步骤：

1. 根据键的哈希值找到对应的桶。
2. 在该桶中搜索是否存在相同的键。如果存在，删除该键值对。

public void remove(K key) {
    int index = hash(key);
    LinkedList<Entry<K, V>> bucket = buckets[index];
    
    Iterator<Entry<K, V>> iterator = bucket.iterator();
    while (iterator.hasNext()) {
        Entry<K, V> entry = iterator.next();
        if (entry.getKey().equals(key)) {
            iterator.remove();
            return;
        }
    }
}

Entry 类

我们还需要定义一个名为 Entry 的类，用来表示 HashMap 中的键值对。Entry 类包含两个属性：key 和 value。

private static class Entry<K, V> {
    private K key;
    private V value;
    
    public Entry(K key, V value) {
        this.key = key;
        this.value = value;
    }
    
    public K getKey() {
        return key;
    }
    
    public V getValue() {
        return value;
    }
    
    public void setValue(V value) {
        this.value = value;
    }
}

示例代码

下面是一个完整的示例代码，包括了上述介绍中的所有部分：

public class HashMap<K, V> {
    private LinkedList<Entry<K, V>>[] buckets;
    private int size;

    public HashMap(int size) {
        this.size = size;
        buckets = new LinkedList[size];
        for (int i = 0; i < size; i++) {
            buckets[i] = new LinkedList<>();
        }
    }

    private int hash(K key) {
        int hashCode = key.hashCode();
        return hashCode % size;
    }

    public void put(K key, V value) {
        int index = hash(key);
        LinkedList<Entry<K, V>> bucket = buckets[index];

        for (Entry<K, V> entry : bucket) {
            if (entry.getKey().equals(key)) {
                entry.setValue(value);
                return;
            }
        }

        Entry<K, V> newEntry = new Entry<>(key, value);
        bucket.add(newEntry);
    }

    public V get(K key) {
        int index = hash(key);
        LinkedList<Entry<K, V>> bucket = buckets[index];

        for (Entry<K, V> entry : bucket) {
            if (entry.getKey().equals(key)) {
                return entry.getValue();
            }
        }

        return null;
    }

    public void remove(K key) {
        int index = hash(key);
        LinkedList<Entry<K, V>> bucket = buckets[index];

        Iterator<Entry<K, V>> iterator = bucket.iterator();
        while (iterator.hasNext()) {
            Entry<K, V> entry = iterator.next();
            if (entry.getKey().equals(key)) {
                iterator.remove();
                return;
            }
        }
    }

    private static class Entry<K, V> {
        private K key;
        private V value;

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

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }

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

结语

通过本篇博客，我们了解了如何用 Java 手写一个简单的 HashMap。我们通过确定基本数据结构、实现哈希函数、解决冲突以及实现基本操作等步骤，完成了一个功能完善的 HashMap。希望本篇博客能够帮助你更好地理解 HashMap 的实现原理，并在实际应用中发挥作用。