HashMap，这一篇就够了

已于 2023-02-25 22:37:09 修改
阅读量3k 收藏 10
点赞数 1
文章标签： java 开发语言
于 2022-11-23 22:23:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55076626/article/details/128008026
版权

一、HashMap的简单使用

HashMap集合的创建：

Map<String,String> map = new HashMap<String,String>();

使用put存储数据：

map.put("张三","喜欢打游戏");
map.put("李四","喜欢睡觉");
map.put("王五","喜欢看电视");
map.put("赵六","喜欢洗澡");

使用get获取数据：

System.out.println(map.get("张三"));
System.out.println(map.get("李四"));

通过Map.keySet使用iterator遍历HashMap：

// 通过Map.keySet使用iterator遍历key,然后通过key得到对应的value值
Iterator<String> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
    String key = iterator.next();
    String value = map.get(key);
    System.out.println("key = " + key + ", value = " + value);
}

通过Map.entrySet使用iterator遍历HashMap：

// 通过Map.entrySet使用iterator遍历key和value；注意 Set entrySet()：返回所有key-value对构成的Set集合
Iterator<Map.Entry<String, String>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
    Map.Entry<String, String> entry = entries.next();
    System.out.println(entry);
}

通过Map.keySet遍历HashMap：

// 通过Map.keySet遍历key,然后通过key得到对应的value值
for (String key : map.keySet()) {
    System.out.println("key = " + key + ", value = " + map.get(key));
}

通过For-Each迭代entries，使用Map.entrySet遍历HashMap：

// 使用For-Each迭代entries，通过Map.entrySet遍历key和value
for (Map.Entry<String, String> entry : map.entrySet()) {
    System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue());
}

使用lambda表达式ForEach遍历HashMap：

// 使用lambda表达式forEach遍历
map.forEach((k, v) -> System.out.println("key = " + k + ", value = " + v));

二、HashMap的底层原理

HashMap本身就是一个程序/工具类，主要用来存储数据

程序=数据结构+算法

数据结构：数组、链表、红黑树

算法：哈希算法

HashMap的数据结构在1.8之前是“数组+链表”

数组：

采用一段连续的存储单元来存储数据

/**
 * 数组
 */
public class MyArray {
    public static void main(String[] args) {
        Integer integer[] = new Integer[10];
        integer[0] = 0;
        integer[1] = 1;
        integer[9] = 2;
        integer[9] = 100;
        System.out.println(integer[9]);
    }
}

特点：查询o(1),删除o(N)

总结：查询快，插入慢

ArrayList的数据结构就是数组：

链表：

链表是一种物理存储单元上非连续、非顺序的存储结构

/**
 * 链表
 */
public class Node {

    public Node next;
    private Object data;

    public Node(Object data){this.data= data;}

    public static void main(String[] args) {
        Node head = new Node("睡觉");
        head.next = new Node("吃饭");
        head.next.next = new Node("打游戏");
        System.out.println(head.data);
        System.out.println(head.next.data);
        System.out.println(head.next.next.data);
    }
}

特点：插入、删除时间复杂度o(1),查找遍历时间复杂度o(N)

总结：插入快，查找慢

LinkedList的数据结构就是链表：

哈希算法：

/**
 * ascii码
 */
public class AsciiCode {
    public static void main(String[] args) {
        char c[] = "lies".toCharArray();
        for (int i = 0; i < c.length; i++) {
            System.out.println((c[i])+"："+(int)c[i]);
        }
    }
}

“取模”的目的是为了节省空间.

但如果两个字符串的ascii码计算结果相同，再进行取模，则会发生“哈希冲突”。.

因为HashMap的数据结构包含了“链表”，而链表就是解决哈希冲突这一问题的关键。

HashMap对产生哈希冲突的数据会以“链表”的形式来存储它们，其它数据则以“数组”的形式存储。

HashMap的数据结构在1.8之后是“数组+链表+红黑树”

由于“链表”查询速度慢的原因，所以新增了“红黑树”：

如上图，这是一个以“链表”形式存储数据的图示

假如我要查询“004”，“005”，“007”则会从001到007查询7次

上图是一个以“红黑树”形式存储数据的图示

红黑树结构特征：“左中右”对应“小中大”

使用“红黑树”查询“004”，“005”，“007”则只需要要查询4次即可

这里要注意，java1.8之后，HashMap默认的数据结构一开始仍然是“数组+链表”，但是当链表的阈值达到8的时候就会变成“数组+红黑树”

查看HashMap源码，点进putVal方法：

点进642行的常量，发现对应的数值就是8：

再看putVal方法中的treeifyBin方法：

此方法一开始执行的是“链表（执行Node）”，而随着条件的改变就变成了“红黑树（执行TreeNode）”：

这里，你可能会好奇，明明知道了“链表”的查询速度慢，为什么一开始不使用“数组+红黑树”？？？

这就好比“鱼和熊掌不可兼得”。

因为“红黑树”在插入数据的时候需要做“数据左旋（也可以理解为数据位置交换）”的动作，所以“红黑树”的插入速度慢。

而“链表”它的插入速度快，和红黑树相反，所以才有了“当链表的阈值达到8的时候就会变成“数组+红黑树””这一说法。

不知道“阈值”是什么意思的小伙伴可以去百度一下。

三、手写一个HashMap

Map<K,V>接口：

/**
 * K V
 * @param <K>
 * @param <V>
 */
public interface Map<K,V> {
    V put(K k,V v);
    V get(K k);
    int size();

    interface  Entry<K,V>{
        K getKey();
        V getValue();
    }
}

HashMap<K,V>，实现Map<K,V>接口：

/**
 * 手写实现HashMap
 * @param <K>
 * @param <V>
 */
public class HashMap<K,V> implements Map<K,V> {

    Entry<K,V> [] table =null;
    int size = 0;

    public HashMap() {
        table = new Entry[16];
    }

    /**
     * 1、key进行hash 取模算出index下标
     * 2、数组的对应节点对象 对象是否为空
     * 3、如果为空的话 赋值存储
     * 4、如果不为空的话 冲突 链表存储
     * 5、返回值
     * @param k
     * @param v
     * @return
     */
    @Override
    public V put(K k, V v) {
        //1、key进行hash 取模算出index下标
        int index = hash(k);
        //2、数组的对应节点对象 对象是否为空
        Entry<K, V> entry = table[index];
        if (null == entry){
            //3、如果为空的话 赋值存储
            table[index]=new Entry<>(k,v,index,null);
            size++;
        }else {
            //4、如果不为空的话 冲突 链表存储
            table[index]=new Entry<>(k,v,index,entry);
        }
        //5、返回值
        return table[index].getValue();
    }

    private int hash(K k) {
        int index = k.hashCode()%16;
        return index>=0?index:-index;
    }

    /**
     * key 进行hash index下标
     * 是否为空 如果为空 直接返回null
     * 不为空 k 当前k进行比较
     * 如果相等 直接返回数据
     * 如果不相等 next是否为空
     * 如果为空 直接返回
     * 如果不为空
     * k是否key是否相等 直到相等为止
     * @param k
     * @return
     */
    @Override
    public V get(K k) {
        int index = hash(k);
        Entry<K,V> entry = findValue(table[index],k);
        return entry==null?null:entry.getValue();
    }

    public Entry<K,V> findValue(Entry<K,V> entry,K k){
        if (k.equals(entry.getKey())||k==entry.getKey()){
            return entry;
        }else {
            if (entry.next!=null){
                return findValue(entry.next,k);
            }
        }
        return null;
    }

    @Override
    public int size() {
        return size;
    }

    class Entry<K,V> implements Map.Entry<K, V> {
        K k;V v;int index;Entry<K,V> next;

        public Entry(K k, V v, int index, Entry<K, V> next) {
            this.k = k;
            this.v = v;
            this.index = index;
            this.next = next;
        }

        @Override
        public K getKey() {
            return k;
        }

        @Override
        public V getValue() {
            return v;
        }
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        HashMap<Object, Object> map = new HashMap<>();
        map.put("张三","喜欢打游戏");
        map.put("王五","喜欢看电视");
        System.out.println(map.get("张三"));
        System.out.println(map.get("王五"));
    }
}

测试结果：

喜欢打游戏
喜欢看电视

长头发的程序猿
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hashmap
weixin_46157928的博客
11-04 139
Hashmap是将map集合以(k，v)的形式存入到数组+链表的集合中。Hashmap添加对象一定要重写equals和hashcode方法。 jdk1.7中 为什么hashmap的默认table长度为16，这样是为了做什么？ 存放一个键值对到一个hashmap的要用k值拿到一个entry对象，entry对象计算出所需的hashcode值，然后存放到链表中！这种插入的方法采用头插法的方式插入到数组对应的链表中。 用到链表的话就需要定义一个next属性，这个属性是为了将相同hash值放入相同的数组“下标
学习Java HashMap，看这篇就够了
08-18
Java HashMap 是一种常用的数据结构，它实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度。HashMap 是一个散列表，它存储的内容是键值对（key-value）映射。 HashMap 的特点： * 无序的，不...
HashMap介绍和使用
09-28
HashMap介绍和使用
Java 8系列之重新认识HashMap
美团技术团队
06-24 1万+
摘要 HashMap是Java程序员使用频率最高的用于映射(键值对)处理的数据类型。随着JDK（Java Developmet Kit）版本的更新，JDK1.8对HashMap底层的实现进行了优化，例如引入红黑树的数据结构和扩容的优化等。本文结合JDK1.7和JDK1.8的区别，深入探讨HashMap的结构实现和功能原理。 简介 Java为数据结构中的映射定义了一个接口java.u...
Java [ 基础 ] HashMap详解 ✨
最新发布
lenyan~的博客
07-04 2335
HashMap是Java中一个强大且高效的集合类，用于快速查找和存储键值对。理解其工作原理和常用操作对于提高编程效率和解决复杂问题非常有帮助。
hashmap
byteyoung
08-24 425
一、HashMap 集合简介 HashMap 基于哈希表的 Map 接口实现，是以 key-value 存储形式存在，即主要用来存放键值对。HashMap 的实现不是同步的，这意味着它不是线程安全的。它的 key、value 都可以为 null，此外，HashMap 中的映射不是有序的。 jdk1.8 之前 HashMap 由 数组 + 链表 组成，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突（两个对象调用的 hashCode 方法计算的哈希值一致导致计算的教组索引值相同）而
hashmap面试题_hashmap_
10-01
本篇将围绕HashMap的相关面试题，从基础概念到高级应用进行详尽解析。 一、HashMap概述 HashMap是一个基于哈希表实现的键值对存储结构，它提供了快速的插入、删除和查找操作，平均时间复杂度为O(1)。HashMap非线程...
HashMap
12-22
HashMap 在 JDK 1.7 中 HashMap 是以数组加链表的形式组成的，...JDK 1.8 之所以添加红黑树是因为一旦链表过长，会严重影响 HashMap 的性能，而红黑树具有快速增删改查的特点，这样就可以有效的解决链表过长时操作比较
C语言实现hashMap
11-10
C语言实现hashMap，包含创建hashMap、插入hashMap、查找hashMap、删除hashMap，已经若干经典的hash函数。文章链接：https://blog.csdn.net/sxf1061700625/article/details/109594495
Java HashMap实现原理分析（一）
09-07
为了提高效率并减少碰撞，HashMap对这个哈希值进行了一次优化处理。具体做法是将哈希值进行无符号右移16位，然后与原哈希值进行异或操作。这样做的目的是使得低位和高位的信息混合，使得哈希分布更加均匀，降低冲突...
HashMap的使用方法详解
热门推荐
sanmi8276的博客
11-24 3万+
HashMap是一种十分常用的数据结构对象，可以保存键值对，下面将详细介绍HashMap的使用方法。 一、添加方法 put方法，可以单次向HashMap中添加一个键值对。 注意：添加到Map中的数据，与List不一样，是没有顺序的。顺序是根据哈希算法得出的，不用深究。 putAll方法，可以把一个HashMap集合对象，整体加入到另外一个HashMap对象中。 注意：两个集合中重复的元素，会被覆盖为新的值。 END 二、删除方法 remove方法，可以单次
hashMap
mimsmile的博客
06-16 140
1.hashMap的数据结构 hashMap底层采用数组+链表的形式存放数据（JDK1.8之后，引入了红黑树）。当存一个数据时，首先使用hashCode（）方法计算这个数据的hash值，hash值确定这个数据存放在数组的哪一个位置，也就是我们所说的哪一个bucket中。确定存放的bucket之后，如果存入的值不等于当前bucket的值，则以链表的形式存放在链表的末尾，当链表的长度超出了一定长度之...
hashmap常见用法
2201_75410538的博客
03-19 316
11、entrySet()： 将Map集合每个key-value转换为一个Entry对象并返回由所有的Entry对象组成的Set集合。9、containsValue(Object value)： 判断集合中是否包含指定值，包含返回 true，否则返回false。8、containsKey(Object key)： 判断集合中是否包含指定键，包含返回 true，否则返回false。2、get(Object key)： 返回指定键所映射的值，没有该key对应的值则返回 null。
HashMap的使用
yuan_boss的博客
06-06 435
HashMap的使用 HashMap和HashSet类似，不过HashMap存储的的键值对，他们的存储结构都是哈希值（数组+链表+红黑树），所以他们在确认元素是否重复时都必须重写equals与hashcode方法。 JDK1.2版本开始出现，线程不安全，只用于单线程，运行效率快；允许使用null作为key或是value Student类（重写equals与hashcode方法） public class Student { private String name; private int a
HashMap使用
Mona_lxh的博客
03-13 869
当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。 package MONA.demo01; import java.util.HashMap; import java.util.Objects; /** * 自定义对象作为Kkey * 当自定义对象作为key时，自定义对象必须重写一下两个方法 * hashCode * equals */ public c
Java-HashMap
07-30 96
Map的结构： HashMap：它根据键的hashCode值存储数据，大多数情况下可以直接定位到它的值，因而具有很快的访问速度，但遍历顺序却是不确定的。 HashMap最多只允许一条记录的键为null，允许多条记录的值为null。HashMap非线程安全，即任一时刻可以有多个线程同时写HashMap，可能会导致数据的不一致。如果需要满足线程安全，可以用 Collecti...
HashMap<String,String>
01-14
HashMap是Java中的一个主要的Map实现类，它是基于哈希表的数据结构来存储键值对。HashMap是线程不安全的，但是它的效率很高。HashMap允许存储null的key和value。 下面是一个演示HashMap的例子： ```java import java.util.HashMap; public class HashMapDemo { public static void main(String[] args) { // 创建一个HashMap对象 HashMap<String, String> hashMap = new HashMap<>(); // 添加键值对 hashMap.put("key1", "value1"); hashMap.put("key2", "value2"); hashMap.put("key3", "value3"); // 获取值 String value = hashMap.get("key2"); System.out.println("Value for key2: " + value); // 输出：Value for key2: value2 // 判断是否包含某个键 boolean containsKey = hashMap.containsKey("key3"); System.out.println("Contains key3: " + containsKey); // 输出：Contains key3: true // 删除键值对 hashMap.remove("key1"); // 遍历HashMap for (String key : hashMap.keySet()) { String val = hashMap.get(key); System.out.println(key + ": " + val); } } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值