每日一省之————利用数组和链表实现一个简单的HashMap

每日一问:简述Java中HashMap 和 HashTable jdk1.7的HashMap是用:数组+链表 jdk1.8的HashMap是用:数组+链表+红黑树HashMap是一个集合,键值对的集合,源码中每个节点用Node表示。 Node是一个内部类,这里的key为键,value为值,next指向下一个元素,可以看出HashMap中的元素不是一个单纯的键值对,还包含下一个元素的引用。哈希表(Hash table,也叫散列表),是根据关键码值(Key value)而直接进行访问的数据结构,只要输入待查找的值即key,即可查找到其对应的值。哈希表其实就是数组的... 阅读详情

今天本人想要复习的是哈希表(散列表)的概念及具体实现,为此用java写了一个简单的实现,但仅仅只是实现了一些简单的功能,不过通过这个简单的实现的确可以帮助我们进一步理解JDK中的HashMap,当然,想要进一步了解就直接阅读JDK中的HashMap的源码啦。

实现代码如下,有注释,本人就不进一步阐述了:

/**
 * 该类是HashMap的一个简单实现。
 * 
 * 这里,我主要采用一个元素是链表的数组来模拟JDK中的HashMap实现。 当存入一个键值对(K,V)的时候,首先计算键(K)对应的HashCode。这个HashCode的值其实就是具体实现过程中用到的数组的索引。通过计算键的HashCode值便可以知道应该将键值对(K,V)存储在第几个数组元素中。如前所述,每一个数组元素其实又是一个链表。将键值对存入散列表其实是存入底层数组元素对应的链表结构中。之所以使用链表作为数组元素是为了避免HashCode相同但又不相等的键造成冲突时候相互覆盖的问题。这样就很好的解决了可能存在的碰撞冲突问题。
 * 
 * @author lhever
 *
 * @param <K>
 * @param <V>
 */
public class SimpleHashMap<K, V> {
    public static final int INITIAL_CAPACITY = 4;

    private int N;
    private int M;
    private SequentialST<K, V>[] table;

    /**
     * 构造
     */
    public SimpleHashMap() {
        this(INITIAL_CAPACITY);
    }

    /**
     * 构造,可以指定底层数组的大小
     * 
     * @param M
     */
    public SimpleHashMap(int M) {
        this.M = M;
        table = (SequentialST<K, V>[]) new SequentialST[M];
        for (int i = 0; i < M; i++) {
            table[i] = new SequentialST<K, V>();
        }

    }

    /**
     * 重新调整底层数组的大小,从实现的角度看,所有已经 存入的键值对会被从新计算散列值并调整存储的位置。
     * 
     * @param newSize
     */
    private void resize(int newSize) {
        SimpleHashMap<K, V> temp = new SimpleHashMap<K, V>(newSize);
        for (int i = 0; i < M; i++) {
            for (K key : table[i].keys()) {
                temp.put(key, table[i].get(key));
            }
        }
        this.M = temp.M;
        this.N = temp.N;
        this.table = temp.table;
    }

    private int hash(K key) {
        return (key.hashCode() & 0x7fffffff) % M;
    }

    public int size() {
        return N;
    }

    public boolean isEmpty() {
        return size() == 0;
    }

    public boolean contains(K key) {
        if (key == null) {
            throw new NullPointerException("参数不能为null");
        }
        return get(key) != null;
    }

    public V get(K key) {
        if (key == null) {
            throw new NullPointerException("参数不能为null");

        }
        int i = hash(key);
        return table[i].get(key);
    }

    public void put(K key, V val) {
        if (key == null) {
            throw new NullPointerException("key不能为null");
        }
        if (val == null) {
            remove(key);
            return;
        }

        // 当链表中的平均元素个数大于10的时候增加底层数组的大小(变为两倍大)
        if (N >= 10 * M) {
            resize(2 * M);
        }

        int i = hash(key);
        if (!table[i].contains(key)) {
            N++;
        }
        table[i].put(key, val);
    }

    public void remove(K key) {
        if (key == null) {
            throw new NullPointerException("参数不能为null");
        }

        int i = hash(key);
        if (table[i].contains(key)) {
            N--;
            table[i].delete(key);
        }

        // 如果列表中的平均元素个数小于等于2的时候,降低底层数组的大小(变为原来大小的1/2)
        if (M > INITIAL_CAPACITY && N <= 2 * M) {
            resize(M / 2);
        }
    }

    // 返回一个迭代器,其中包含了所有的键
    public Iterable<K> keys() {
        Queue<K> queue = new LinkedList<K>();
        for (int i = 0; i < M; i++) {
            for (K key : table[i].keys())
                queue.offer(key);
        }
        return (Iterable<K>) queue;
    }

    /**
     * 测试
     * 
     * @param args
     */
    public static void main(String... args) {

        SimpleHashMap map = new SimpleHashMap<String, String>();

        map.put("country", "China");
        map.put("level", "super");
        map.put("nature", "public");

        System.out.println(map.get("country"));
        System.out.println("befor remove, the size is: " + map.size());
        map.remove("country");
        System.out.println("after remove, the size is: " + map.size());

        for (String key : (Iterable<String>) map.keys()) {
            System.out.println(key + " : " + map.get(key));
        }

        map.remove("nature");
        map.remove("level");
        map.remove("level");
        System.out.println("after remove, the size is: " + map.size());

        for (String key : (Iterable<String>) map.keys()) {
            System.out.println(key + " : " + map.get(key));
        }

        map.put("size", "960");
        System.out.println("after put, the size is: " + map.size());
    }

}


////////////////////////////////////////////////////

package lhever.Hash_Map;

import java.util.LinkedList;
import java.util.Queue;

/**
 * 该类是一个顺序查找的链表实现,查找元素时候会从第一个节点开始顺序查找,
 * 该链表实现会被用到SimpleHashMap(JDK中HashMap的一个简单实现)的实现中
 * 
 * @author lhever
 *
 * @param <K>
 * @param <V>
 */
public class SequentialST<K, V> {
    private int N;
    private Node first;

    /**
     * 代表一个节点
     * 
     * @author lhever
     */
    private class Node {

        private K key;
        private V value;
        private Node next;

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

    }

    public SequentialST() {

    }

    public int size() {
        return N;
    }

    public boolean isEmpty() {
        return size() == 0;
    }

    public boolean contains(K key) {
        if (key == null)
            throw new NullPointerException("参数不能为null");
        return get(key) != null;
    }

    /**
     * 查找从第一个节点开始顺序进行
     * 
     * @param key
     * @return
     */
    public V get(K key) {
        if (key == null)
            throw new NullPointerException("参数不能为null");
        for (Node node = first; node != null; node = node.next) {
            if (key.equals(node.key))
                return node.value;
        }
        return null;
    }

    /**
     * 增加
     * 
     * @param key
     * @param value
     */
    public void put(K key, V value) {
        if (key == null)
            throw new NullPointerException("参数不能为null");
        if (value == null) {
            delete(key);
            return;
        }

        for (Node node = first; node != null; node = node.next) {
            if (key.equals(node.key)) {
                node.value = value;
                return;
            }
        }
        first = new Node(key, value, first);
        N++;
    }

    public void delete(K key) {
        if (key == null)
            throw new NullPointerException("参数不能为null");
        first = delete(first, key);
    }

    private Node delete(Node node, K key) {
        if (node == null)
            return null;
        if (key.equals(node.key)) {
            N--;
            return node.next;
        }
        node.next = delete(node.next, key);
        return node;
    }

    public Iterable<K> keys() {
        Queue<K> queue = new LinkedList<K>();
        for (Node node = first; node != null; node = node.next)
            queue.offer(node.key);
        return queue;
    }

}



每日一面系列之HashMap夺命连环问 集合框架必问之HashMap连环夺命问,看看你能答上来多少! 阅读详情

相关推荐

【重磅更新】CT/MRI LI-RADS 2024:肝细胞癌局部区域治疗后反应评估的核心突破与临床实践指南

减少过度治疗:辐射 LRT 的 Nonprogressing 类别避免了 “持续强化 = 存活” 的误判,降低不必要的再治疗风险;提高检出效率:非辐射 LRT 的辅助特征升级减少了 Equivocal 比例,更早识别存活肿瘤;统一评估语言:标准化的分类标准为放射科、肝病科、肿瘤科、肝移植科的多学科协作(MDT)提供了统一 “沟通工具”,助力治疗方案的精准制定。

楚山之石的博客 1228

HashMap的实现原理详解(看这篇就够了)

HashMap底层结构?基于Map接口的实现,数组+链表的结构,JDK 1.8后加入了红黑树,链表长度>8变红黑树,<6变链表两个对象的hashcode相同会发生什么?Hash冲突,HashMap通过链表来解决hash冲突HashMap 中 equals() 和 hashCode() 有什么作用?HashMap 的添加、获取时需要通过 key 的 hashCode() 进行 hash(),然后计算下标 ( n-1 & hash),从而获得要找的同的位置。

bjmsb79的博客 2432

统信UOS服务器上,达梦DM8数据库安装避坑全记录(附大小写敏感设置)

本文详细介绍了在统信UOS服务器版上部署达梦DM8数据库的全过程,包括环境准备、安装流程、数据库实例初始化及关键参数配置,特别是大小写敏感设置的注意事项。提供了从系统配置到性能优化的完整指南,帮助用户避免常见问题,确保数据库稳定运行。

weixin_30647423的博客 333

手写基于数组+链表的HashMap

手写一个基于数组+链表的HashMap,实现基础功能。

qq_57585993的博客 826

Windows 11下manage-bde命令实战:BitLocker锁了别慌,手把手教你用命令行找回数据

本文详细介绍了在Windows 11系统下使用manage-bde命令解锁BitLocker加密驱动器的实战方法。通过命令行诊断、恢复密钥获取、解锁流程演示及高级故障排除,帮助用户在系统锁定后快速找回数据,特别适合IT技术人员和遇到紧急情况的用户。

weixin_30902251的博客 334

激光三角测量法:斜射与直射式技术的原理与应用解析

本文深入解析激光三角测量法中斜射式与直射式技术的原理、应用及对比。斜射式适用于高精度小范围测量,尤其擅长处理反光表面;直射式则适合大范围位移检测,结构更简单。文章详细介绍了两种技术的光路分析、数学建模、应用场景及选型建议,并探讨了系统校准与误差分析方法,为工业检测领域提供实用参考。

weixin_29280219的博客 415

利用数组+链表的方式实现HashMap的一些功能

HashMap、Hashcode

m0_64508778的博客 1898

【Bluedroid】AVRCP 连接源码分析(一)

AVRCP连接源码分析流程是一个涉及多个步骤和协议交互的复杂过程。在源码中,需要仔细处理各种连接状态和协议交互,以确保AVRCP连接的稳定性和可靠性。同时,还需要根据具体的应用场景和需求,对AVRCP命令和响应进行定制化处理。

byte轻骑兵的技术小窝 3320

使用链表+数组,手写HashMap

使用链表+数组,手写HashMap 在jdk1.7版本的HashMap 底层采用了链表+数组的方式实现数据的存储及扩容等,在jdk1.8后HashMap的底层换为红黑树+数组的方式。这边以链表+数组的方式模仿源码写一个自己的简易HashMap。 一、效果演示 其中初始容量设为的10,负载因子设定0.5,上面效果已有了扩容的效果。 二、实现 1. 思路 因为是基于链表+数组实现的,所以要定义一个Node链表数组,有数组肯定需要定义数组的大小,这里默认是10,源码默认是16。看过源码的肯定知道还要设定一个

小毕超博客 1377

VN5620以太网测试——DoIP配置

CANoe(CAN open environment)VN5620 :是一个紧凑而强大的接口,用于以太网网络的分析、仿真、测试和验证。VN5620 接口支持各种可能的应用。它适用于与其他总线系统、网络参与(例如在模拟和生成帧、测试中的负载和错误)的同步以太网监控。在2021年Vector公司的以太网接口卡VN5610和VN5640设备已经陆续停产,相应被VN5620和VN5650代替。参考文章了解DoIP协议——汽车以太网应用介绍。

诊断协议那些事儿's blog 3029

DXF转G代码是圆弧的方向如何确定?

🏆本文收录于 《全栈 Bug 调优(实战版)》 专栏。专栏聚焦真实项目中的各类疑难 Bug,从成因剖析 → 排查路径 → 解决方案 → 预防优化全链路拆解,形成一套可复用、可沉淀的实战知识体系。无论你是初入职场的开发者,还是负责复杂项目的资深工程师,都可以在这里构建一套属于自己的「问题诊断与性能调优」方法论,助你稳步进阶、放大技术价值 。

**My Coding Family** 1191

实现一个简单的哈希表(数组 + 链表)

1、什么是哈希表 2、主要方法的逻辑和代码实现 1)put()方法 2)get()方法 3) remove()方法 1、哈希表 hash,哈希表这个词,以前接触过好多次了,对哈希表了解最多的就是,这玩意儿也是一种数据结构,而且哈希表查找、添加和删除元素都很快。 哈希表,跟链表一样,大都使用结点类型来存储值。哈希表的存储类型是种叫 键值对 <K, V> 的东西。 在本文中,我用的是一个数...

weixin_44501074的博客 2285

ESP-SPARKBOT AI 智能机器人:v1.2 全流程复刻指南

本文介绍 ESP-SPARKBOT AI 智能机器人 v1.2 版本的全流程复刻,包含 PCB 、3D 打印、固件烧录、常见问题解决、参考资料等

举世誉之而不加劝,举世非之而不加沮,定乎内外之分,辩乎荣辱之境,斯已矣。 9263

【Android每日一问】HashMap相关问题

文章会持续更新的。绝对干货!!!Android进阶学习全套手册关于实战,我想每一个做开发的都有话要说,对于小白而言,缺乏实战经验是通病,那么除了在实际工作过程当中,我们如何去更了解实战方面的内容呢?实际上,我们很有必要去看一些实战相关的电子书。

2401_84132617的博客 620

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

每日面试题01 HashMap的底层原理

即使未触发数组扩容,若某个桶的链表长度超过 8(且数组长度 ≥ 64),会转换为红黑树,占用更多内存。​)时,为了优化查询效率(链表的查询时间复杂度为 O(n),红黑树为 O(logn)),会将链表转换为红黑树(需同时满足数组长度 ≥ 64,避免数组过小时频繁转换)。红黑树与链表的转换需要额外的计算和内存操作(如红黑树的旋转、颜色调整,或链表节点的指针修改),频繁切换会显著影响性能。当数组长度 ≥64 时,若红黑树节点数降至 6 以下,说明冲突已缓解(可能因扩容或数据分布变化),此时退化为链表可节省内存。

2303_76837797的博客 1284

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

每日学习03--HashMap

HashMap数据结构

Cai_Xu_Kun的博客 658

Java岗大厂面试百日冲刺 - 日积月累,每日三题【Day12】—— 集合框架2(HashMap)

同学们,HashMap实在是重点中的重点,面试考察概率很高!各面试官对其掌握的认知程度却并不相同,若你的理解超出面试官的认知范围,自然是强加分项,一定要掌握!上车!

陈哈哈的菜园子 1万+

hashmap怎么取值_每日一面系列之HashMap夺命连环问

1.HashMap的底层数据结构是什么?底层数据结构是哈希表结构(链表散列:数组+单向链表),结合了数组和链表的优点,当链表长度超过8时,链表会转为红黑树。数组中的每一个元素都是链表。总结来说就是HashMap在JDK1.8之前底层是由数组+链表实现的,在JDK1.8开始底层是由数组+链表或者数组+红黑树实现的。追问:为什么在1.8中增加红黑树?当需要查找某个元素的时候,线性探索是最直白...

weixin_39628160的博客 386

Java每日一学之HashMap和HashTable

HashMap HashMap是基于哈希表实现的,每个元素以key-value形式存储,内部以链表形式进行扩张,当容量超过阈值的时候,会自动增长 非线程安全,只适用于单线程环境下 支持序列化 key value都运行为null,key为null的放在第一个链表中。 内部存储数据的Entry数组默认为16 默认的加载因子为0.75 HashTable Hashtable同样是基于哈希表...

Eggy个蛋 265

【每日面试2】请说出Java中HashMap的原理是什么?

【每日面试2】请说出Java中HashMap的原理是什么?

程序猿老白~的博客 1195

【面试八股文】每日一题:hashmap源码面试21连问?

任意长度的输入->固定长度的输出。

weixin_35714418的博客 1293
上一篇: 有关js的一些好文收录——会持续更新
下一篇: 每日一省之—使用线性探测法(仅利用数组作为底层数据结构)实现HashMap
lhever_
博客等级 码龄14年 213粉丝 130原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值