手写HashMap

已于 2022-08-09 13:50:14 修改
阅读量387 收藏
点赞数
文章标签： 哈希算法 散列表 java 链表
于 2022-08-02 13:13:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47844533/article/details/126120110
版权

目录

一、基于 hash 算法、单向链表、数组实现 HashMap

1.1 MyHashMap类

1.2 Entry类

1.3 Student类

1.4 启动类/测试类

二、基于ArrayList实现HashMap

2.1 MyHashMap类

2.2 Entry类

2.3 启动类/测试类

一、基于 hash 算法、单向链表、数组实现 HashMap

说明：使用hash算法实现hashMap要注意发生hash冲突，为了解决这个问题，因此使用了单向链表对集合中的键值对进行存储。

对上述图片进行讲解：entyr 即一个黄色小框框，为数组中一个对象，代表hashMap集合中的键值对元素；0，1，2...1000则为该数据的链表；“key=2”和“key=4”为两个键值对对象，这里假设“key=2”以及“key=4”的两个对象的hashCode值相等，由于“key=2”的键值对先存进数组中，因此“key=4”的键值对通过单向链表的方式追加到“key=2”的键值对后面。那么为什么会出现链表的方式？原因是通过hash算法会存在hash冲突的问题，本文的hash算法为：存放地址 = key的hash值 取余 数组的长度。代码意思就是：index = key.hashCode() % entries.length，因此若两个键值对对象的key的hash值相同，则存放的位置肯定是相同，因此通过链表的方式解决这一hash冲突。

本文实现了HashMap的重要的方法以及特点，如：只能存放唯一个key值，并且key值以及Value值均可以存放自定义对象，并且解决了hash冲突。但当存放自定义对象作为key值的时候，需要重写该对象的equals()方法以及hashCode()方法。

hash冲突：根据key（键）即经过一个函数f(key)得到的结果的作为地址去存放当前的key value键值对(这个是hashmap的存值方式)，但是却发现算出来的地址上已经被占用了。这就是所谓的hash冲突。而本文的函数 f 的实现大概就是：存放地址 = key的hash值 取余 数组的长度。代码意思就是：index = key.hashCode() % entries.length

注：本文还存在一个问题，本文存储集合中的键值对的主要方式是通过数组的方式，而为了提高查询效率，有时候增加数组的长度是非常必要的，需要用到数组内容的扩容机制，后续会慢慢更新，读者也可以自行的去解决

1.1 MyHashMap类

package com.mingfa.work01;

import java.util.ArrayList;
import java.util.Map;

/**
 * 基于 hash 算法、单向链表、数组实现 HashMap
 * @param <K>
 * @param <V>
 */
public class MyHashMap<K,V> {
    //Entry为存放集合的键值对，即 <key,value>
    private Entry[] entries = new Entry[10];//假设数组容量为10，但是实际上是可以动态修改，因为存在扩容机制

    /**
     * 为集合添加数据
     * @param k key 值
     * @param v value 值
     */
    public void put(K k,V v){
        /**
         * 1、根据 key 的 hashcode 取余 entrys.length ， 余数为该 key 存放在我们数组中对应的 index 位置
         * 2、判断该位置是否存在键值对
         * 3、如果是，则查看该结点以及相应的链表是否存在以 k 为 key 的值
         * 4、如果没有，则在最后面插入
         */
        int hash = Math.abs(k.hashCode());//去 key 值的hash值，注意这里需要确保为整数，因为 hash 值是用来觉得该键值对存放在数据的位置，而数组的索引必须大于等于0
        int index = hash % entries.length;//这是本文的 hash 算法，根据key的哈希值决定键值对的存放索引
        Entry oldEntry = entries[index];//取该索引的键值对
        //看当前数组节点是否为空
        if (oldEntry == null) {//若当前索引不存在键值对
            entries[index] = new Entry<>(k,v,hash);//则将该键值对插入
            return;
        }
        //若不为空，则遍历链表
        for(;;){
            //查看链表（包括首结点）是否存在当前key值，若是，则更换 value 值
            if (oldEntry.getKey().equals(k)){
                oldEntry.setValue(v);
                return;
            }
            //若不存在，则查找该结点的下一个结点
            if (oldEntry.getNext() == null){//若下一个结点为空，则追加到链结点尾部
                oldEntry.setNext(new Entry(k,v,hash));
                return;
            }else{//否则取下一个结点，继续循环
                oldEntry = oldEntry.getNext();
            }
        }
    }

    /**
     * 根据 key 取 value
     * @param k key 值
     * @return value 值
     */
    public V get(K k){
        /**
         * 1、通过 hash 算法找到数组中的链表首结点
         * 2、通过for循环查找 key 为 k 的 value
         * 注：如果是存放自定义对象作为 key 值，这里需要注意 hashCode() 以及 equals() 方法的重写
         */
        //根据 hash 算法先获取 entries 数组的某个位置
        int hash = Math.abs(k.hashCode());
        int index = hash % entries.length;
        //判断该位置上是否存在键值对，如果是，则遍历以该结点为头的链表，从而寻找 key 为 k 的 value
        for (Entry<K,V> entry = entries[index];entry != null;entry = entry.getNext()){
            if (entry.getHash() == hash && (entry.getKey() == k || entry.getKey().equals(k)))
                return entry.getValue();
        }
        return null;
    }

    /**
     * 获取集合大小
     * @return 集合大小
     */
    public int size(){
        int count = 0;//记录集合大小
        Entry entry = null;//用来遍历键值对
        //以数组的长度为循环结束条件
        for (int i = 0;i<entries.length;i++){
            if (entries[i] != null){
                entry = entries[i];
                count++;//如果当前有对象，则集合大小+1
                //遍历以该结点为首结点的链表
                while (entry.getNext() != null){
                    count++;//当下一个结点不为空时，则+1
                    entry = entry.getNext();
                }
            }
        }
        return count;
    }

    /**
     * 通过 ArrayList 取集合中全部的 value 值
     * @return 集合中全部的 value 值
     */
    public ArrayList arrayListGetValues(){
        ArrayList arrayList = new ArrayList();//存放结果
        Entry entry = null;//用来遍历键值对
        //以数组的长度为循环结束条件
        for (int i = 0;i < entries.length;i++){
            if (entries[i] != null){
                arrayList.add(entries[i].getValue());//如果结点不为空，则将该结点的 value 值加入到列表中
                entry = entries[i];//取该结点
                //死循环，遍历以该结点为首结点的链表
                for (;;){
                    if (entry.getNext() != null){//如果该结点存在下一个结点，则将下一个结点存放在列表
                        arrayList.add(entry.getNext().getValue());
                        entry = entry.getNext();
                    }else break;//遍历完整条链表，退出死循环
                }
            }
        }
        return arrayList;
    }

    /**
     * 通过 ArrayList 取集合中全部的 key 值
     * @return 集合中全部的 key 值
     */
    public ArrayList arrayListGetKeys(){
        //该方法实现逻辑同上
        ArrayList arrayList = new ArrayList();
        Entry entry = null;
        for (int i = 0;i < entries.length;i++){
            if (entries[i] != null){
                arrayList.add(entries[i].getKey());
                entry = entries[i];
                for (;;){
                    if (entry.getNext() != null){
                        arrayList.add(entry.getNext().getKey());
                        entry = entry.getNext();
                    }else break;
                }
            }
        }
        return arrayList;
    }

    /**
     * 通过 ArrayList 取集合中的全部键值对
     * @return 集合中的全部键值对
     */
    public ArrayList<Entry> arrayListGetKeyAndValue(){
        //该方法实现逻辑同上
        ArrayList<Entry> arrayList = new ArrayList();
        Entry entry = null;
        for (int i = 0;i < entries.length;i++){
            if (entries[i] != null){
                entry = entries[i];
                arrayList.add(new Entry(entry.getKey(),entry.getValue()));
                for (;;){
                    if (entry.getNext() != null){
                        entry = entry.getNext();
                        arrayList.add(new Entry(entry.getKey(),entry.getValue()));
                    }else break;
                }
            }
        }
        return arrayList;
    }
}

1.2 Entry类

存放集合中的键值对，一个Entry对象为一个键值对 <key，value>

package com.mingfa.work01;

/**
 * 存放集合中的 键值对
 * @param <K>
 * @param <V>
 */
public class Entry<K,V> {
    private K key;//存放 key 值
    private V value;//存放 value 值
    private int hash;// 存放 hashCode 值
    public Entry<K,V> next;//存放集合元素，解决hash冲突

    public Entry(K k, V v, int hash) {
        this.key = k;
        this.value = v;
        this.hash = hash;
    }

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

    public K getKey() {
        return key;
    }

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

    public V getValue() {
        return value;
    }

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

    public int getHash() {
        return hash;
    }

    public void setHash(int hash) {
        this.hash = hash;
    }

    public Entry<K, V> getNext() {
        return next;
    }

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

1.3 Student类

package com.mingfa.work01;


public class Student {
    private Integer id;
    private String name;

    public Student(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    //注：无论是手写的hashMap集合，还是java提供的hashMap集合，当以自定义对象为 key 值的时候，需要重写 equals 以及 hashMap 方法

    /**
     * 重写 equals 方法
     * @param o
     * @return
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return this.id.equals(student.id) && this.name.equals(student.name);
        //return Objects.equals(this.id,student.id) && Objects.equals(this.name,student.name);
    }

    /**
     * 重写 hashCode 方法
     * @return
     */
    @Override
    public int hashCode() {
        return this.id.hashCode() + this.name.hashCode();
        //return Objects.hash(id, name);
    }

    /**
     * 重写 toString 方法，方便打印
     * @return
     */
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

1.4 启动类/测试类

package com.mingfa.work01;

import java.util.*;

public class test {
    public static void main(String[] args) {
        MyHashMap map = new MyHashMap<>();
        /**
         * 存放 a ,97 或者 b ,98，是为了测试 hash 冲突对该集合的影响
         * 原因是 a 的哈希值与97的哈希值均是97。其他雷同
         */
        map.put("a","123");
        map.put(97,"789");
        map.put("a","aaa");
        map.put(97,"977");
        map.put("b","bbb");
        map.put(98,"988");
        map.put("c","ccc");
        map.put(99,"999");
        /**
         * 测试存放两个内容相同的自定义对象，集合是否能够有效处理
         */
        map.put(new Student(1,"mingfa"),"mingfafa");
        map.put(new Student(1,"mingfa"),"mingfafa1");
        map.put(new Student(2,"mingfa"),"mingfafa2");
        map.put("mingfa",new Student(1,"jinjin"));
        map.put("mingfa",new Student(2,"jinjin"));
        map.put("haha",new Student(3,"jinjin"));

        System.out.println("集合长度为："+map.size());//输出：10
        System.out.println("key为a的value为："+ map.get("a"));//输出：aaa
        System.out.println("key为97的value为："+ map.get(97));//输出：977
        System.out.println("集合中全部的key："+map.arrayListGetKeys());
        System.out.println("集合中全部的value："+map.arrayListGetValues());
        System.out.print("集合中全部的键值对：");
        ArrayList<Entry> arrayList = map.arrayListGetKeyAndValue();
        for (Entry entry : arrayList){
            System.out.print(entry.getKey()+"-"+entry.getValue()+"   ");
        }
        System.out.println();
        System.out.println(map.get(new Student(1, "mingfa")));//输出：mingfafa1

    }
}

二、基于ArrayList实现HashMap

2.1 MyHashMap类

package com.mingfa.work01;

import java.util.ArrayList;

/**
 * 使用 ArrayList 实现 HashMap 
 * 缺点:
 * 1、效率低，原因是 ArrayList 的底层实现是数据的形式实现
 * 优点：
 * 1、保证存放的键值对是有序存放，而不是无序的
 * @param <K>
 * @param <V>
 */
public class MyHashMap<K,V> {
    private ArrayList<Entry<K,V>> arrayList = new ArrayList<>();

    /**
     * 插入数据
     * @param k key 值
     * @param v value 值
     */
    public void put(K k,V v){
        //先查看集合中是否存在该 key 值
        for (Entry entry : arrayList){
            if (entry.getK().equals(k)) {//当 map 集合存放自定义对象，需要重写 equals() 以及 hashCode() 方法
                entry.setV(v);
                return;
            }
        }
        //若不存在，则添加
        arrayList.add(new Entry<>(k,v));
    }

    /**
     * 根据 key 得到 value
     * @param k key 值
     * @return value 值
     */
    public V get(K k){
        for (Entry entry: arrayList) {
            if (entry.getK().equals(k)) return (V)entry.getV();
        }
        return null;
    }

    /**
     * 返回集合大小
     * @return 集合大小
     */
    public int size(){
        return arrayList.size();
    }
}

2.2 Entry类

package com.mingfa.work01;

/**
 * 存放集合中的 键值对
 * @param <K>
 * @param <V>
 */
public class Entry<K,V> {
    private K k;//存放 key 值
    private V v;//存放 value 值

    public Entry(K k, V v) {
        this.k = k;
        this.v = v;
    }

    public K getK() {
        return k;
    }

    public V getV() {
        return v;
    }

    public void setK(K k) {
        this.k = k;
    }

    public void setV(V v) {
        this.v = v;
    }
}

2.3 启动类/测试类

package com.mingfa.work01;

import java.util.ArrayList;

/**
 * 使用 ArrayList 实现 HashMap 
 * 缺点:
 * 1、效率低，原因是 ArrayList 的底层实现是数据的形式实现
 * 优点：
 * 1、保证存放的键值对是有序存放，而不是无序的
 * @param <K>
 * @param <V>
 */
public class MyHashMap<K,V> {
    private ArrayList<Entry<K,V>> arrayList = new ArrayList<>();

    /**
     * 插入数据
     * @param k key 值
     * @param v value 值
     */
    public void put(K k,V v){
        //先查看集合中是否存在该 key 值
        for (Entry entry : arrayList){
            if (entry.getK().equals(k)) {//当 map 集合存放自定义对象，需要重写 equals() 以及 hashCode() 方法
                entry.setV(v);
                return;
            }
        }
        //若不存在，则添加
        arrayList.add(new Entry<>(k,v));
    }

    /**
     * 根据 key 得到 value
     * @param k key 值
     * @return value 值
     */
    public V get(K k){
        for (Entry entry: arrayList) {
            if (entry.getK().equals(k)) return (V)entry.getV();
        }
        return null;
    }

    /**
     * 返回集合大小
     * @return 集合大小
     */
    public int size(){
        return arrayList.size();
    }
}
weixin_19210075002
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java手写一个简单的HashMap
TheCalm的博客
08-19 1736
1.背景介绍 HashMap在Java中是常用的数据结构之一。HashMap 是一个散列表，它存储的内容是键值对(key-value)映射，并具有很快的访问速度。在JDK1.7中，HashMap是基于“数组+链表”实现的，而在JDK1.8以后，HashMap在底层实现中加入了红黑树用于提升查找速率。 图源网络，侵删 在JDK1.8中，当链表的长度大于阈值8时，这时这个链表将会转化成红黑树以提升查找效率。为什么阈值是8呢？请读者不妨思考一下这个问题，在文章末尾笔者将给出原因。（提示：想一想在红黑树和链表中
手写map
Circ
07-02 315
HashMap是Java中一中非常常用的数据结构，也基本是面试中的“必考题”。它实现了基于“K-V”形式的键值对的高效存取。JDK1.7之前，HashMap是基于数组+链表实现的，1.8以后，HashMap的底层实现中加入了红黑树用于提升查找效率。HashMap根据存入的键值对中的key计算对应的index，也就是它在数组中的存储位置。当发生哈希冲突时，即不同的key计算出了相同的index，HashMap就会在对应位置生成链表。当链表的长度超过8时，链表就会转化为红黑树。
最新Java手写Hashmap(HashMap的基本用法)，含小米、腾讯、阿里
最新发布
2401_84007015的博客
05-14 643
这些面试题是我朋友进阿里前狂刷七遍以上的面试资料，由于面试文档很多，内容更多，没有办法一一为大家展示出来，所以只好为大家节选出来了一部分供大家参考。//只是位运算 效率高 其效果与取模运算一样（v%(length - 1)）面试的本质不是考试，而是告诉面试官你会做什么，所以，这些面试资料中提到的技术也是要学会的，不然稍微改动一下你就凉凉了。//如果新节点的键值 等于 该该链表当中的数据 则覆盖。//此处数组元素为空，则直接将新节点放进去。//此处数组元素不为空，则遍历对应的链表。
手写一个HashMap（附demo，有注释，复制就能跑）
秃头计划——启动！
01-05 1273
手写HashMap，你上你也行！
全手写HashMap精简版Demo 可直接允许查看效果
06-03
在这个“全手写HashMap精简版Demo”中，我们将探讨其基本构造、哈希函数、链表处理冲突以及插入和查找操作的实现。 首先，哈希表是一种数据结构，它通过计算元素的哈希值将数据分布在一个数组中，这样可以快速定位...
java代码-使用java解决手写hashMap的源代码
03-20
java代码-使用java解决手写hashMap的源代码 ——学习参考资料：仅用于个人学习使用！
手写HashMap源码.rar
02-22
《手写HashMap源码解析——深入理解数据结构与算法》 HashMap是Java编程语言中一个常用的集合类，它提供了一种高效、灵活的键值对存储方式。在面试过程中，尤其是2020年及以后的技术面试中，深入理解HashMap的实现...
48-Java知识点 手写HashMap1
08-08
在Java编程中，HashMap是一种常用的集合类，它提供了一种快速存取键值对的方式。HashMap基于哈希表的原理实现，其内部结构是数组加链表，JDK1.8之后如果链表长度超过8则会转换为红黑树，以优化查找性能。本文将深入...
Java手写简易版HashMap的使用（存储+查找）
08-25
Java手写简易版HashMap的使用（存储+查找） Java手写简易版HashMap是Java中的一种常用的数据结构，它提供了高效的存储和查找键值对的功能。下面我们将详细介绍Java手写简易版HashMap的使用，包括存储和查找键值对的...
Java手写实现HashMap
2301_79108888的博客
09-14 343
我们将创建一个名为HashMap的类，其中包含一个构造函数，用于初始化哈希表。首先，我们定义一个数组bucket，用来存储桶的信息。在构造函数中，我们可以指定哈希表的大小，例如size。然后，我们初始化bucket数组，并将每个桶都初始化为一个空链表。这样，我们就完成了哈希表的初始化。i < size;i++) {通过本篇博客，我们了解了如何用 Java 手写一个简单的 HashMap。
java小白翻身-手写HashMap
java小白翻身
09-27 729
什么是HashMap 这一节课，我们来手写一个简单的HashMap，所谓HashMap，就是一个映射表。 比如现在我有一个客户类，就用之前的就好。 现在我有100个客户，名字各不相同，有叫张三的，也有叫李四的，还有的人叫张全蛋。如果现在要你从这100个人中找到一个叫做王尼玛的人，你怎么办？ 这好像很简单，我们不是刚刚做了一个TuziLinkedList吗？一个个add进去，数据初始化，然后再用foreach去遍历不就行了？可是，这样的效率是很低的，假如王尼玛正好在链表的最后一个，那就需要遍历100次才能找
简单手写HashMap源码
菜鸟新人
01-12 435
public class ExtHashMap { LinkedList[] tables = new LinkedList[990]; private int size; public void put(Object key, Object value) { // 创建ExtEntry对象 ExtEntry extEntry = new ExtEntry(key, value)...
HashMap彻底搞懂+手写实现
后端领域、分布式、高并发、微服务、性能优化文章分享
02-09 674
HashMap彻底搞懂+手写实现前言一、技术介绍1.HashMap是什么？二、底层原理1.数组2.链表三、单元测试总结作者寄语 提示：下方有源代码地址，请自行拿取 前言 你是不是还在面试时被面试官问懵HashMap？不会手写实现一个简单HashMap？看完这篇文章你再不会算我输！ 提示：以下是本篇文章正文内容，案例仅供参考 一、技术介绍 1.HashMap是什么？ 基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null
手写简易HashMap
qq_34565436的博客
07-15 129
代码-手写简易HashMap。
手写HashMap（JDK8）第二天
zjltju1203的博客
05-20 2541
左旋右旋-动态演示 树的左旋右旋 ， 多层左旋右旋 红黑平衡 ，红黑树修改平衡
纯手写HashMap集合框架
会飞的鱼
05-17 351
HashMap集合原理在面试中问的特别多，已经发布《纯手写HashMap集合框架》，详细讲到，多种方式实现HashMap集合，基于Arraylist实现hashMap集合 基于LinkeList实现HashMap集合 基于单链表+数组实现HashMap集合 基于红黑树+数组实现HashMap Hash碰撞问题如何解决的，HasMap...
手写hashmap
05-26
好的，这里是一个简单的手写hashmap的实现： ```java public class MyHashMap, V> { private int size; private int capacity; private Node, V>[] table; private static class Node, V> { final K key; V ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值