通过自定义一个HashMap来学习HashMap的数据结构

最新推荐文章于 2024-02-11 02:00:00 发布
最新推荐文章于 2024-02-11 02:00:00 发布
阅读量468 收藏 2
点赞数
分类专栏： JavaSE 文章标签： java hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/byteArr/article/details/103233615
版权

写在最前：首先要搞清楚HashMap的数据结构是怎样的，它是用来解决什么问题的，以及该数据结构中体现javabean结构的成员变量，有参/无参构造，成员方法等是如何定义的。

本文所写的数据结构模拟的是jdk7，数组+链表。jdk8的红黑树只是优化链表，后续更新。

可以参考下我之前的文章：《HashMap源码分析（jdk8）》

我们先思考几个问题：

1. 有哪些成员变量？各自的默认值是什么？

2. 有哪些构造方法？

3. 有哪些成员方法？

4. 数组是如何定义的？

5. 链表是如何定义的？

6. 什么是hash冲突，它什么时候发生？该怎么解决？

7. map的put方法，如何判定key是否重复？

8. 何时扩容？

9. hashmap如何优化？

10. 欢迎评论区补充，一起探讨

我们先通过自定义一个HashMap来了解这种数据结构，再来回答这些问题。

1. 定义MyMap接口

/**
 * @author yog
 *
 * 自定义map接口
 * @param <K> key
 * @param <V> value
 */
public interface MyMap<K,V> {

    /**
     * put
     * @param k key
     * @param v value
     * @return value
     */
    V put(K k,V v);

    /**
     * get
     * @param k key
     * @return alue
     */
    V get(K k);

    /**
     * 内部接口，存放key-value的entry桶
     * @param <K> key
     * @param <V> value
     */
    interface Entry<K,V>{

        /**
         * getKey 获取key
         * @return key
         */
        K getKey();

        /**
         * getValue 获取value
         * @return value
         */
        V getValue();
    }
}

暂定一个get和一个put方法。

2. 定义MyHashMap，实现MyMap接口

public class MyHashMap<K,V> implements MyMap<K,V> {

    @Override
    public Object put(Object o, Object o2) {
        return null;
    }

    @Override
    public Object get(Object o) {
        return null;
    }
}

2.1 成员变量

    /**
     * 定义数组初始化容量 32
     */
    private static final int DEFAULT_INITIAL_CAPATITY = 1 << 4;

    /**
     * 定义加载因子 0.75f
     */
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 默认初始化容量
     */
    private transient int defaultInitSize;

    /**
     * 默认加载因子
     */
    private final float defaultLoadFactor;

    /**
     * entry数组
     */
    private Entry<K,V>[] table;

    /**
     * map中entry数量
     */
    private int entryUseSize;

2.2 构造方法

    //这里两个构造方法其实指向同一个构造方法，但对外暴露两个，"门面模式"
    MyHashMap(){
        this(DEFAULT_INITIAL_CAPATITY,DEFAULT_LOAD_FACTOR);
    }

    private MyHashMap(int defaultInitialCapatity, float defaultLoadFactor) {
        if(defaultInitialCapatity < 0){
            throw new IllegalArgumentException("非法初始化容量异常：" + defaultInitialCapatity);
        }

        if (defaultLoadFactor <= 0 || Float.isNaN(defaultLoadFactor)){
            throw new IllegalArgumentException("非法初始化加载因子异常" + defaultLoadFactor);
        }

        this.defaultInitSize = defaultInitialCapatity;
        this.defaultLoadFactor = defaultLoadFactor;

        table = new Entry[this.defaultInitSize];
    }

2.3 定义Entry数组

    /**
     * @author yog
     * @param <K> key
     * @param <V> value
     *
     * 内部类
     */
    static class Entry<K,V> implements MyMap.Entry<K,V>{

        private K key;

        private V value;

        private Entry<K,V> next;

        public Entry(){}

        private 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;
        }
    }

2.4 put方法

    @Override
    public V put(K k, V v) {
        V oldValue = null;

        //是否需要扩容
        if(entryUseSize >= defaultInitSize * defaultLoadFactor ){
            //扩容完毕，重新散列
            resize(2 * defaultInitSize);
        }

        //求hash值，计算在数组中的位置
        int index = hash(k) & (defaultInitSize - 1);
        if(null == table[index]){
            table[index] = new Entry<K,V>(k,v,null);
            ++entryUseSize;
        }else {
            //需要遍历单链表
            Entry<K,V> entry = table[index];
            Entry<K,V> e = entry;
            while (null != e){
                if(k == e.getKey() || k.equals(e.getKey())){
                    oldValue = e.value;
                    e.value = v;
                    return oldValue;
                }
                e = e.next;
            }
            table[index] = new Entry<K,V>(k,v,entry);
            ++entryUseSize;
        }
        return oldValue;
    }

2.5 resize扩容

    //参考jdk的hashap的hash运算
    private int hash(K k){
        int hashCode = k.hashCode();
        hashCode ^= (hashCode >>> 20) ^ (hashCode >>> 12);
        return hashCode ^ (hashCode >>> 7) * (hashCode >>> 4);
    }

    //从这里可以看到resize/rehash的操作是影响性能的，需要数组的重新put操作。但要注意状态变量的变化
    private void resize(int i){
        Entry[] newTable = new Entry[i];
        //改变数组的大小
        defaultInitSize = i;
        entryUseSize = 0;
        rehash(newTable);
    }

    private void rehash(Entry<K,V>[] newTable) {
        //将旧table遍历，放入新集合中
        List<Entry<K,V>> entries = new ArrayList<>();
        for (Entry<K, V> entry : table) {
            if(null != entry){
                do{
                    entries.add(entry);
                    entry = entry.next;
                }while (null != entry);
            }
        }

        //覆盖旧的引用
        if(newTable.length > 0){
            table = newTable;
        }

        //重新hash：重新put entry到hashMap
        for (Entry<K, V> entry : entries) {
            put(entry.getKey(),entry.getValue());
        }
    }

2.6 get方法

    @Override
    public V get(K k) {

        int index = hash(k) & (defaultInitSize - 1);
        if(null == table[index]){
            return null;
        }else {
            Entry<K, V> entry = table[index];
            do {
                if(k == entry.getKey() || k.equals(entry.getKey())){
                    return entry.getValue();
                }
                entry = entry.next;
            }while (null != entry);
        }

        return null;
    }

3. 测试

public class MyHashMapTest {

    public static void main(String[] args) {
        MyMap<Integer,String> myMap = new MyHashMap<>();
        for (int i = 0; i < 100; i++) {
            myMap.put(i,"value" + i);
        }

        for (int i = 0; i < 100; i++) {
            System.out.println("key : " + i + " , value : " + myMap.get(i));
        }
    }

}

测试结果：

4. 分析HashMap数据结构

4.1 成员变量

  • 数组默认的初始化容量DEFAULT_INITIAL_CAPATITY为32（必须是2的次幂），默认的加载因子DEFAULT_LOAD_FACTOR为0.75f。初始化容量决定hashmap中初始化时存放的元素数量，加载因子决定hashmap何时进行扩容。当HashMap中元素数量超过 初始化容量*加载因子 时，就进行扩容resize()操作，如达到 16*0.75=12时，就进行扩容，默认扩容为原来的两倍，16*2=32。
  • Entry数组：它是一个静态的内部类。从Entry的构造函数可以看出，每次创建新的Entry对象，就会把链表的头结点作为next拼接到新的entry对象上。也就是说每次插入新的map数据时，就会生成一个bucket在链表头部。由此可以得出单链表的实现方式。
  • 在jdk8之后，采用了红黑树来优化单链表。当哈希冲突比较多的时候,因为链表的长度很大 , 链表是不利于查询的,有利于删除和插入,所以引进了红黑树,每一个链表分成奇偶两个子链表分别挂在新链表数组的散列位置。若桶（hashmap的table数组）中链表元素超过8，会自动转化成红黑树；若桶中元素小于等于6时，树结构还原成链表。红黑树的平均查找长度是log(n)，长度为8，查找长度为log(8)=3，链表的平均查找长度为n/2，当长度为8时，平均查找长度为8/2=4，这才有转换成树的必要；链表长度如果小于等于6，6/2=3，虽然速度也很快，但是转化为树和生成树的时间并不会太短。中间的差值7为了防止链表和树频繁的转换，试想如果一个HashMap不停的插入、删除元素，链表个数在8左右徘徊，就会频繁的发生树转链表、链表转树，效率会很低。
  • 扩容resize：扩容后需要再哈希rehash。put操作时也要判断是否需要扩容。rehash操作时，先用一个新的数组接受原数组，重新put entry到新数组中。
  • hash：参考jdk的hash运算。
  • rehash操作/resize操作可以看出是需要开销的，所以主要优化的地方也在这里。如果业务中能判断初始化容量，可以提前设置好初始化参数。而默认加载因子0.75f是平衡了时间和空间等因素； 负载因子越小桶的数量越多，读写的时间复杂度越低（极限情况O(1), 哈希碰撞的可能性越小）； 负载因子越大桶的数量越少，读写的时间复杂度越高(极限情况O(n), 哈希碰撞可能性越高)。 0.1，0.9，2，3等都是合法值。

4.2 构造方法

  • 无参构造：它并没有实际的操作，而是调用有参构造。源码中它的作用是初始化一些参数。
  • 有参构造：初始化参数。初始化加载因子和初始化容量。

4.3 成员方法

4.3.1 put方法

  1. 首先根据当前数组容量，来判断是否需要扩容；如果需要扩容，需要进行rehash操作。
  2. 之后根据put时的key来计算hash值，计算在数组中的位置；如果hash值在数组中不存在，就直接将元素设置到数组中，并且容量加一；否则遍历该索引位置上的单链表，如果单链表已存在value，就替换，并将旧值返回；如果不存在就set该元素到链表头位置，同时容量加一。

4.3.2 get方法

      首先计算key的hash值，如果hash值为null，说明数组中不存在该key，就返回null；如果hash值存在，通过该hash值得到数组中的Entry位置，并且判断该位置上的元素的key和请求参数key是否相同（需要==和equals同时比较），如果相同则返回该value，否则返回null。

 

代码复制粘贴完即可运行。欢迎评论指正！

 

laoyog
关注
专栏目录
HashMap
zuoyonggang
07-28 1139
hashMap的结构示意图如下：       基本原理：先声明一个下标范围比较大的数组来存储元素。另外设计一个哈希函数（也叫做散列函数）来获得每一个元素的Key（关键字）的函数值（即数组下标，hash值）相对应，数组存储的元素是一个Entry类，这个类有三个数据域，key、value（键值对），next(指向下一个Entry)。  例如， 第一个键值对A进来。通过计算其key的hash得...
HashMap的自定义实现
HugeBrian的博客
07-15 585
文章目录前言一、HashMap是什么？二、代码实现1.01.引入库2.读入数据总结 前言 HashMap是Map集合中的重要组成部分，也是我们在实际编程中经常会使用到的一种数据类型。所以为了学习散列表，我决定对HashMap进行自我重构，同时将我编写的HashMap与系统自带的HashMap进行效率比对。 提示：以下是本篇文章正文内容，下面案例可供参考 一、HashMap是什么？ 写代码之前，我们需要先了解一下，什么是HashMap？HashMap的使用场景是什么？这是一个线程安全的类吗？以下我将一一解
自定义一个简易的HashMap
qq_45275227的博客
07-15 556
自娱自乐 看看就好 自己写一个简易的HashMap public class sxtHashMap<K,V>{ Node[] weitong;//位桶数组 int size;//存放键值对的个数 public sxtHashMap(){ weitong = new Node[16];//长度一般是2的整数次幂 } public V get(K key) { int hash = myHash(key.hashCode(), weitong.length);
自定义一个HashMap
LY_yhq
08-13 258
package mycollection; /** 自定义一个HashMap 实现了put方法增加键值对，并解决了键重复的时候覆盖相应的节点的问题 @author */ public class TestHashMap { Node2[] table;//位桶数组 bucket array int size; public TestHashMap() { table = new Node...
自定义 HashMap
最新发布
学无止境
02-11 609
【代码】自定义 HashMap。
自定义HashMap
weixin_41047492的博客
12-26 1024
package cn.sxt.mycollection; /** 自定义一个HashMap 实现get方法，根据键对象获得对应的值对象 */ public class HashMap04&lt;K,V&gt; { Node3[] table; //位桶数组。bucket array int size; //存放的键值对的个数 public SxtHashMap04() { ...
自定义类实现HashMap的部分功能
candycrush_CL的博客
07-10 572
Java—HashMap HashMap的简单总结 ​ HashMap是Java中Map接口的实现类，继承自AbstractMap。HashMap中的数据是以键值对K-V的形式储存的，每一个键key对应唯一一个值value，并且这个key键可以得到Set集，无序不可重复，而value值可以通过Collection容器获取，可以重复。 遍历方式 public class Test { public static void main(String[] args) { HashMap<String,
剖析Java中HashMap数据结构的源码及其性能优化
09-02
总结来说，Java的HashMap通过哈希表和链表/红黑树的数据结构实现高效的键值对存储。其性能优化主要体现在合理的装载因子设置、动态扩容策略以及在高冲突情况下利用红黑树提升性能。理解这些机制对于开发者来说至关...
自定义实现常用数据结构 -java版代码.rar
02-08
本压缩包提供的"自定义实现常用数据结构 - java版代码.rar"聚焦于几个关键的数据结构，包括HashMap、LinkedHashMap以及与之相关的红黑树。下面我们将深入探讨这些核心知识点。 首先，HashMap是Java中最常用的一种...
Java实现自定义HashMap
m0_38036210的博客
08-26 840
1.HashMap的实现原理 HashMap底层实现采用了哈希表，这是一种非常重要的数据结构。 哈希表的基本结构是数组加链表。 able：核心存储结构，也称之为“位桶数组” transient Node<K,V>[] table; 2.代码实现 HashMap存储键值对的过程？ 1.调用Object.hashCode() 2.HashMap.hash() 3.根据hash,将Node存...
自定义实现HashMap(简单实现)
小飞飞飞贼的博客
08-08 426
/** * @author ZhangHaiWen &lt;/a&gt; * @create 2018/8/8 0008 * @desc 自定义的HashMap **/ public class MyHashMap implements HashMap { private Node[] tables; private int iniSize; public MyHashM...
数据结构08-散列(自定义HashMap)
冰生于水的博客
09-04 212
实现自定义的HashSet之后HashMap也自然水到渠成了，作者的实现方法是以HashSet的方式来类比实现HashMap，而JavaAPI中标准的HashSet是基于HashMap的，因为Map中的keySet方法就是返回一个HashSet，所以只需要隐藏掉Value的相关操作，稍加改造就可以实现HashSet，减少代码冗余。 作者的这种方法虽然相对于标准的JavaAPI来说有些冗余，但十分...
HashMap集合的自定义实现
天堂的博客
12-24 1373
HashMap集合是Map接口的实现类，在Map集合不同于Collectiion集合，Map集合存放的是键值对，通过键(key)可以找到对应的值（value），而且每一个key是唯一的。那么该如何自定义实现HashMap呢？ 通过阅读jdk的源代码，发现HashMap的底层数据结构其实就是数组加上链表。笔者通过阅读源码，自定义实现了HashMap。 数组里面存放的是链表LinkedList，而
HashMap的数据结构
热门推荐
Watson的博客
11-04 1万+
HashMap的数据结构数组的特点是：寻址容易，插入和删除困难；而链表的特点是：寻址困难，插入和删除容易。那么我们能不能综合两者的特性，做出一种寻址容易，插入删除也容易的数据结构？答案是肯定的，这就是我们要提起的哈希表，哈希表有多种不同的实现方法，我接下来解释的是最常用的一种方法—— 拉链法，我们可以理解为“链表的数组”，如图： 从上图我们可以发现哈希表是由数组+链表组成的，一个长度为16的数组中
自定义数据结构—MyHashMap
iteye_10401的博客
11-02 179
[size=medium]在学习了数据结构HashMap之后，自己也定义了一个MyHashMap，下面来解析一下MyHashMap。[/size] [size=x-large]1、实质为一个数组[/size] [size=medium]我定义的MyHashMap中所使用的数据结构是一个数组，数据都存储在这个数组中。当然你肯定有疑问，若是用这个数组的话那得要多大的数组...
模仿源码自定义HashMap
易水南风的专栏
05-10 1079
HashMap的实现原理简单来说是通过数组加链表实现的，结合数组查找和链表插入删除效率高，使得HashMap在数据处理方面高效。链表元素是键值对数据,数组元素为链表（源码中为链表的第一个键值对元素），同一个链表的元素是键值哈希值对数组长度取余结果相同的键值对，而它们的键值哈希码对数组长度取余结果恰好作为数组的下标，查找更为方便。详细的实现可参考这篇文章： http://blog.csdn.n
自定义简单实现hashmap
miracleon的博客
10-14 925
首先定义一个节点 package TestList.TestMap; public class Node2<K,V> { int hash; K key; V value; Node2 next; } 接着就是具体实现 package TestList.TestMap; /** * 自定义Hashmap * 采用数组+链表形式存储元素 * h...
自定义ListView布局：Hashmap与自定义适配器绑定数据详解
总结来说，这篇文章主要讲解了如何使用HashMap作为数据结构，结合自定义布局，实现ListView中每一项的复杂数据绑定。通过这种方式，我们可以灵活展示多个字段，增强了应用的可定制性和用户体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值