Java常见集合框架(十九)： Map之Map、AbstractMap、HashMap

最新推荐文章于 2024-03-07 17:44:44 发布
最新推荐文章于 2024-03-07 17:44:44 发布
阅读量637 收藏
点赞数 1
分类专栏： Java Java常见集合框架 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a355586533/article/details/78298003
版权

Map结构图
这里写图片描述

Map

public interface Map

  1. 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
  2. 此接口取代 Dictionary 类，后者完全是一个抽象类，而不是一个接口。
  3. Map 接口提供三种collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。
  4. 键注意其自身 equals 和 hashCode 方法。

嵌套类

interface Entry<K,V> {
    /**
	 * 返回Key
	 */
	K getKey();

    /**
	 * 返回value
	 */
	V getValue();

    /**
	 * 特定值value
     */
	V setValue(V value);

	/**
	 * 比较entry是否相同
     */
	boolean equals(Object o);

	/**
	 * 返回entry的哈希码
	 */
	int hashCode();
}

接口定义方法

这里写图片描述

AbstractMap

public abstract class AbstractMap implements Map

  1. 提供Map接口的主要实现，最大限度减少实现此接口的Map所需的工作。

该抽象类为子类提供了Map接口的接口方法默认实现，子类可根据需要覆写父类方法，除了两个方法没提供默认实现。
要实现可修改的映射，编程人员必须另外重写此类的 put 方法。

	public V put(K key, V value) {
		throw new UnsupportedOperationException();
    }

HashMap

public class HashMap extends AbstractMap implements Map ,Cloneable, Serializable

  1. 基于哈希表的 Map 接口的实现。
  2. 允许使用 null 值和 null 键。
  3. HashMap 的实例有两个参数影响其性能：初始容量(默认16) 和加载因子(默认0.75)。
  4. 此实现不是同步的，fail-fast。

成员变量

    /**
     * 默认初始容量
     */
    static final int DEFAULT_INITIAL_CAPACITY = 16;

    /**
     * 最大容量
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * 默认加载因子
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * key-value组成Entry存入该数组中
     */
    transient Entry[] table;

    /**
     * key-value键值对数
     */
    transient int size;

    /**
     *  当size达到该值时即capacity * load factor，再rehash
     */
    int threshold;

    /**
     * 加载因子
     */
    final float loadFactor;

    /**
     * 被修改次数
     */
    transient volatile int modCount;
    
    /**
     * 此映射所包含的映射关系的 Set 视图。
     */
    private transient Set<Map.Entry<K,V>> entrySet = null;

构造方法

    /**
     *  构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }
    
    void init() {
    }

内部类Entry成员变量

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;//哈希地址相同的，通过链表链接，即链地址法解决哈希冲突
        final int hash;
    }

常用方法

V put(K key, V value)： 在此映射中关联指定值与指定键。

    public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);//null 专门存入到table[0]
        int hash = hash(key.hashCode());//再哈希
        int i = indexFor(hash, table.length);//根据哈希码机及数组长度计算索引
        //循环对应的table[i]的链表，若key已存在且哈希码相同则替换value
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;//修改次数+1
        addEntry(hash, key, value, i);//存入到指定位置
        return null;
    }
    
    /**
     * 存入key为null的value
     */
    private V putForNullKey(V value) {
	    //key==null的专门放到table[0]中,但也补排除别的键hash地址一样
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {//找到对应key，替换value
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;//修改次数+1
        addEntry(0, null, value, 0);、、
        return null;
    }
    
    /**
     * 以hash, key, value创建新entry并放入到table的指定位置
     */
    void addEntry(int hash, K key, V value, int bucketIndex) {
		Entry<K,V> e = table[bucketIndex];//获取对应索引entry
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);//table[bucketIndex]存入的是一个链表
        if (size++ >= threshold)
            resize(2 * table.length);//元素已到阀值，再扩容
    }
    
    /**
     * 两倍扩容，并进行table转化
     */
    void resize(int newCapacity) {/
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {//已到最大值，更新加载因子,不允许扩容
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);//更新扩容阀值
    }
    
    /**
     * 转移当前全部 entries 到 newTable.
     * 转移过程中，每个entry会重新计算在newTable的index，并存入
     */
    void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }
    
    /**
     * 计算并返回哈希码的index
     */
    static int indexFor(int h, int length) {
        return h & (length-1);
    }

V get(Object key)： 返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。

    public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());//再哈希
        //循环对应table[indexFor(hash, table.length)]的链表
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            //Entry哈希码相同且key相同，映射关系存在，返回对应value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
    }
    
    //从table[0]中找出NullKey的映射关系，并返回对应value
    private V getForNullKey() {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

V remove(Object key)： 从此映射中移除指定键的映射关系（如果存在）。

    public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

    final Entry<K,V> removeEntryForKey(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());//计算哈希码
        int i = indexFor(hash, table.length);//计算table对应index
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;

        while (e != null) {
            Entry<K,V> next = e.next;
            Object k;
            //Entry哈希码相同，key相同 找到对应的映射关系
            if (e.hash == hash && 
	            ((k = e.key) == key || (key != null && key.equals(k)))) {
                modCount++;//修改次数+1
                size--;//映射关系数-1
                if (prev == e)//table[i]和链表头部是同一个entry
                    table[i] = next;//下一个entry前移
                else
                    prev.next = next;//下一个entry前移
                e.recordRemoval(this);
                return e;
            }
            //没有找到对应映射关系，继续找下一个节点
            prev = e;
            e = next;
        }

        return e;
    }

HashMap总结：

  1. 默认初始容量16和默认加载因子0.75，当key-value个数达到初始容量*加载因子时，会现有容量2倍扩容，且容量达到1 << 30时，不再扩容。扩容时会newTable，重新计算每个Entry在newTable的索引，并存入到对应位置，从而将oldTable中全部转移Entry到newTable中。扩容时，在多线程中可能产生条件竞争，从而产生死循环，故避免在多线程中使用HashMap。
  2. 采用数组+链表结构存储元素，链地址法解决哈希冲突。
  3. 当Entry哈希码和key同时相等，才能确定key已存在或找到对应key的entry。
  4. entrySet方法已经返回了key-value映射关系，不要用keySet方法。
  5. 允许使用 null 值和 null 键。

jdk1.8优化：

  1. 采用数组+链表+红黑树结构提高了查找性能。当哈希桶中元素达到TREEIFY_THRESHOLD=8时，由链表转换为红黑树TreeNode。少于8时，又会转换为链表结构。
Believe勤能补拙
关注
专栏目录
Java 集合框架：HashMap 的介绍、使用、原理与源码解析
栗筝i的博客
07-23 6718
HashMap 根据是一个键值对集合，采用 hashCode 值存储数据，大多数情况下可以直接定位到它的值，因而具有很快的访问速度，但遍历顺序却是不确定的。HashMap 最多只允许一条记录的键为 null。HashMap 非线程安全，即任一时刻可以有多个线程同时写 HashMap，可能会导致数据的不一致。如果需要满足线程安全，可以用 Collections 的 synchronizedMap 方法使 HashMap 具有线程安全的能力，或者使用 ConcurrentHashMap。
Map集合之HashMap
桐花思雨
09-09 1351
一：HashMap概述 HashMap 是通过 put(key,value) 存储，get(key)来获取。当传入 key 时，HashMap 会根据 key 的 hashCode() 方法计算出 hash 值，根据 hash 值将 value 保存在 bucket(桶)里。当计算出的 hash 值相同时，称之为 hash 冲突。HashMap 的做法是用 链表和红黑树 存储相同 hash 值的 value 二：Hash冲突，以及解决方法 hash 冲突：两个元素通过 hashCode() 计算出的值是一样
HashMap源码分析（一）--AbstractMap以及Map分析
weixin_30847865的博客
05-13 112
有图可以看出，HashMap继承了AbstractMap，接入了Cloneable接口，Map接口与Serializeble接口。当然排开Cloneable用于允许拷贝，Serializeble用于允许对象的序列化，所以不需要多家赘述。剩下的就只有AbstractMap类与Map接口的分析。 一、Map接口 由于源码比较零散，所以也不截图了 Map作为一个接口，仅仅是用于完成一些初始方法...
Java 集合深入理解（15）：AbstractMap
weixin_34209851的博客
10-27 368
点击查看 Java 集合框架深入理解 系列， - ( ゜- ゜)つロ 乾杯~ 今天来了解下 AbstractMap。 什么是 AbstractMap AbstractMap 是 Map 接口的的实现类之一，也是 HashMap, TreeMap, ConcurrentHashMap 等类的父类。 AbstractMap 提供了 Map 的基本实现...
Map之AbstractMap、HashMap
最新发布
好看的皮囊千篇一律，有趣的灵魂万里挑一。
03-07 1065
基于哈希表的Map接口实现。这个实现提供了所有可选的映射操作，**并允许空值和空键**。(HashMap类大致相当于Hashtable，不同之处在于它是不同步的，并且允许为空。)这个类不保证映射的顺序;特别是，它不能保证顺序在一段时间内保持不变。 该实现为基本操作(get和put)提供恒定时间的性能，前提是哈希函数将元素正确地分散到桶中。对集合视图进行迭代所需的时间与HashMap实例的“容量”(桶的数量)加上它的大小(键值映射的数量)成正比。因此，如果迭代性能很重要，那么不要将初始容量设置得太高(或负载
今天看了下abstractMap和hashMap的源码
dieliyun1509的博客
07-31 105
很长一段时间以来，都没有这个意识去看源码 今天code review的时候，因为自己实现了一段hashcode的compare方法，所以大家拎出来说了一说 1 private boolean compareHashMap(Map<String, Object> newMap, Map<String, Object> originMap) { ...
Java集合中的AbstractMap抽象类
weixin_33743703的博客
03-01 126
jdk1.8.0_144 AbstractMap抽象类实现了一些简单且通用的方法，本身并不难。但在这个抽象类中有两个方法非常值得关注，keySet和values方法源码的实现可以说是教科书式的典范。 　　抽象类通常作为一种骨架实现，为各自子类实现公共的方法。上一篇我们讲解了Map接口，此篇对AbstractMap抽象类进行剖析研究。 　　Java中Map类型的数据结构有相当多，Abstrac...
【Java集合框架深度解析】：Map, Set, List工作机制大揭秘
![【Java集合框架深度解析】：Map, Set, List工作机制大揭秘]...# 1. Java集合框架概述 Java集合框架（Java Collections Framework）是Java编程语言中提供的一组接口、抽象类和实现类的集合，用于表示和操作集合。...
浅析Java中Map与HashMap,Hashtable,HashSet的区别
09-05
在Java编程语言中，`Map`接口是用于存储键值对的数据结构，它不保证元素的顺序，允许null键和null值。`HashMap`、`Hashtable`和`HashSet`都是基于`Map`或`Set`接口实现的不同数据结构，它们在功能、线程安全性和性能...
[Java集合]Map源码分析：HashMap（下）
qq_41655934的博客
04-21 384
Java集合Map源码分析：HashMap（下）1. 视图1.1 keySet()1.2 HashIterator1.3 transient1.4 Spliteratorvalues()entrySet()2. Overrides of JDK8 Map extension methods3. LinkedHashMap support4. Cloning and serialization 1....
详解Java中AbstractMap抽象类
08-27
本篇文章给大家详细介绍了Java集合中的AbstractMap抽象类的相关用法以及知识点总结，需要的朋友参考下。
java集合AbstractMap_Java 集合中的 AbstractMap 抽象类
weixin_42360467的博客
02-26 132
Java 集合中的 AbstractMap 抽象类jdk1.8.0_144AbstractMap 抽象类实现了一些简单且通用的方法, 本身并不难但在这个抽象类中有两个方法非常值得关注, keySet 和 values 方法源码的实现可以说是教科书式的典范抽象类通常作为一种骨架实现, 为各自子类实现公共的方法上一篇我们讲解了 Map 接口, 此篇对 AbstractMap 抽象类进行剖析研究Java...
Java集合类：AbstractMap
10-17 1045
文章目录引言源码解析抽象函数entrySet()两个集合视图操作方法两个子类感谢参考： 引言 今天学习一个Java集合的一个抽象类 AbstractMap ，AbstractMap 是Map接口的 实现类之一，也是HashMap、TreeMap、ConcurrentHashMap 等的父类，它提供了Map 接口中方法的基本实现（关于Map接口有疑惑的同学可参考 Java根接口：Collectio...
Java常用数据结构之Map-AbstractMap
weixin_33957648的博客
11-06 147
前言 Map集合是用来存储&lt;Key, Value&gt;键值对数据的，是日常开发中使用最多的数据结构之一。Map集合相对List集合来说结构会稍微复杂一些，所以Map系列会分开写。本文主要分析AbstractMap。 类图 Map接口中定义了各种基本方法，而键值对数据实际是保存在Entry中的。AbstractMap类和AbstractList类一样，都是一种模板类，提供了Map的基本实现...
java abstractmap_JDK源码学习笔记1-AbstractMap
weixin_28760959的博客
03-04 121
AbstractMap这个类主要是为了减轻实现Map接口的任务而设计的，这样一些简单通用的方法就不用各种Map自己一一实现了。在看这个类的时候，我发现了2个地方是我需要学习的：1、根据需要，一个方法可以写成只抛出一个异常publicVput(Kkey,Vvalue){thrownewUnsupportedOperationException();}AbstractMap实现了Map...
Java源码阅读--AbstractMap
qq_37695054的博客
08-26 220
Java源码阅读–AbstractMap 结构 头： 属性： transient volatile Set<K> keySet; transient volatile Collection<V> values; SimpleEntry 先看一下“头” 实现了Entry，那来看看它的具体实现方法吧（过于简单的方法就不赘述了） 只有俩属性 private final K key; private V value;
Java集合之六—AbstractMap
深入浅出学JAVA
11-09 595
AbstractMap是一个抽象类，它是Map接口的一个骨架实现，最小化实现了此接口提供的抽象函数。在Java的Collection框架中基本都遵循了这一规定，骨架实现在接口与实现类之间构建了一层抽象，其目的是为了复用一些比较通用的函数以及方便扩展，例如List接口拥有骨架实现AbstractList、Set接口拥有骨架实现AbstractSet等。 下面我们按照不同的操作类型来看看Abstra...
java abstractmap,详解Java中AbstractMap抽象类
weixin_39851914的博客
03-19 275
jdk1.8.0_144 下载地址：https://www.jb51.net/softs/551512.htmlAbstractMap抽象类实现了一些简单且通用的方法，本身并不难。但在这个抽象类中有两个方法非常值得关注，keySet和values方法源码的实现可以说是教科书式的典范。抽象类通常作为一种骨架实现，为各自子类实现公共的方法。上一篇我们讲解了Map接口，此篇对AbstractMap抽象类...
Java集合框架深度解析：HashMap与Hashtable的比较
"阿里巴巴面试题主要关注Java集合框架，特别是HashMap和Hashtable的比较。" 在Java编程中，集合框架是一个非常重要的部分，它提供了一种有效地存储和操作数据的方式。面试中经常涉及到的Java集合框架类包括HashMap...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值