HashMap源码理解

最新推荐文章于 2024-11-04 22:26:34 发布
最新推荐文章于 2024-11-04 22:26:34 发布
阅读量70 收藏
点赞数
分类专栏： 天天编程 文章标签： HashMap 源码 java Map

看看HashMap对应的源码。

1.类、接口关系 

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

克隆和序列化不懂，先看Map。

2.实现的接口 Map 

public interface Map<K,V> {
     //这些方法就不用写注释了吧，一看就懂。
     int size();
     boolean isEmpty();
     boolean containsKey(Object key);
     boolean containsValue(Object value);
     V get(Object key);
     V put(K key, V value);
     V remove(Object key);
     void putAll(Map<? extends K, ? extends V> m);
     void clear();
     //这里是返回的不重复的集合
     Set<K> keySet();
     //这里返回的是一个集合
     Collection<V> values();
     Set<Map.Entry<K, V>> entrySet();
     boolean equals(Object o);
     int hashCode();
     //还有一个内部的接口，这个相当于一个key-value数据。
     interface Entry<K,V> {
     	K getKey();
        V getValue();
	V setValue(V value);
        boolean equals(Object o);
	int hashCode();
    }
}

3.继承的抽象类AbstractMap

这个方法有700行，我就挑出几个说一说

3.1构造方法 

public abstract class AbstractMap<K,V> implements Map<K,V> {
    protected AbstractMap() {
    }
}

3.2 几个方法

简单介绍几个，都没什么实际意思。

//声明了抽象变量，里面直接是Map的内部类，这个Set包含着所有的数据key+value
public abstract Set<Entry<K,V>> entrySet();

//Map长度
public int size() {
      return entrySet().size();
}

//是否为空
public boolean isEmpty() {
	return size() == 0;
}

//是否包含某个值
public boolean containsValue(Object value) {
        //要查找出是否包含，于是开始遍历这个Set。
        //这里可以使用 for each，但是这个方法写于jdk1.2，所以当时还没有。遍历的过程很简单。
	Iterator<Entry<K,V>> i = entrySet().iterator();
        //这里还有一个判空。
	if (value==null) {
	    while (i.hasNext()) {
		Entry<K,V> e = i.next();
		if (e.getValue()==null)
		    return true;
	    }
	} else {
	    while (i.hasNext()) {
		Entry<K,V> e = i.next();
                //注意：比较用的是equals，而不是==
		if (value.equals(e.getValue()))
		    return true;
	    }
	}
	return false;
}

//查找这个值，一样遍历Set
public V get(Object key) {
	Iterator<Entry<K,V>> i = entrySet().iterator();
	if (key==null) {
	    while (i.hasNext()) {
		Entry<K,V> e = i.next();
		if (e.getKey()==null)
		    return e.getValue();
	    }
	} else {
	    while (i.hasNext()) {
		Entry<K,V> e = i.next();
		if (key.equals(e.getKey()))
		    return e.getValue();
	    }
	}
	return null;
}

//这个方法是要求重写的。
public V put(K key, V value) {
	throw new UnsupportedOperationException();
}

//删除某个键值对
public V remove(Object key) {
	Iterator<Entry<K,V>> i = entrySet().iterator();
	Entry<K,V> correctEntry = null;
        //key值可以为null，查出相应key值所对应的键值对。
	if (key==null) {
	    while (correctEntry==null && i.hasNext()) {
		Entry<K,V> e = i.next();
		if (e.getKey()==null)
		    correctEntry = e;
	    }
	} else {
	    while (correctEntry==null && i.hasNext()) {
		Entry<K,V> e = i.next();
		if (key.equals(e.getKey()))
		    correctEntry = e;
	    }
	}
        //这里开始删除操作
	V oldValue = null;
	if (correctEntry !=null) {
	    oldValue = correctEntry.getValue();
            //用迭代器的删除方法。
	    i.remove();
	}
        //返回删除的value。
	return oldValue;
}

//添加一个Map操作，直接循环添加
public void putAll(Map<? extends K, ? extends V> m) {
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
            put(e.getKey(), e.getValue());
}

//直接使用了set的clear方法
public void clear() {
	entrySet().clear();
}

AbstractMap就看到这里，毕竟主要是看HashMap。

4.HashMap

4.0文字介绍

HashMap首先会开辟一个16空间的Entry（键值对）数组，

Entry类中包括

final K key;
V value;
Entry<K,V> next;
final int hash;
 

然后对存入的key进行hash运算，算到一个数字（1-15），存入对应位置。

如果对应位置一有数据，则替代当前数据，然后将原数据的引用给新数据，即赋值给next。当存到一定的值后，会扩展空间。

查询的时候将key进行计算得到（1-15），然后查询对应位置，一直去next，知道取到数据或结束。

4.1构造函数。 

public HashMap() {
        //一个倍数 0.75f
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        //临界值 16*0.75=12，表示存了12个值以后要开辟新的空间
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        //初始空间16
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        //init里面没有内容。
        init();
}

4.2 put方法 

public V put(K key, V value) {
        //如果key为空，单独做插入操作。
        if (key == null)
            //插入key为null的值，返回之前此处的值。
            return putForNullKey(value);
        //计算hash值，下面的两个方法
        int hash = hash(key.hashCode());
        //根据hash值获得在数组中的位置
        int i = indexFor(hash, table.length);
        //循环位置。直到为空位置
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //如果包含key值和hash值都相等。
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                //将原有的键值对的value值替换。
                V oldValue = e.value;
                e.value = value;
                //这是替换要执行的方法，现在内部还没有处理。
                e.recordAccess(this);
                //将就得value返回。
                return oldValue;
            }
        }
        //这里代表这个key值要新加入这个map。
        //修改次数
        modCount++;
        //加入
        addEntry(hash, key, value, i);
        return null;
}
//添加一个空的key。添加到数组的0位置。
private V putForNullKey(V value) {
        //判断对应位置时候为空，
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            //对应key值不为空
            if (e.key == null) {
                //更新数据。
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                //返回被替换掉的值。
                return oldValue;
            }
        }
        modCount++;
        //添加一个0位置的。
        addEntry(0, null, value, 0);
        return null;
}
//添加一个键值对，传入对应hash值和数组位置。
void addEntry(int hash, K key, V value, int bucketIndex) {
        //将这个位置的原有值取出来，
	Entry<K,V> e = table[bucketIndex];
        //新建一个，传入hash值，还有它的下一个键值对。所以同一个位置，后面插入的数据会查询快一点点。
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        //如果size大于临界值。
        if (size++ >= threshold)
            //将原来空间扩大为两倍
            resize(2 * table.length);
}
//开辟新空间
void resize(int newCapacity) {
        Entry[] oldTable = table;
        //旧数组的长度
        int oldCapacity = oldTable.length;
        //最大空间数。
        if (oldCapacity == MAXIMUM_CAPACITY) {
            //边界值为int的最大值。
            threshold = Integer.MAX_VALUE;
            //结束。
            return;
        }
        //新建一个数组,大小为传入的数字。
        Entry[] newTable = new Entry[newCapacity];
        //转移新数组
        transfer(newTable);
        //给table赋值。
        table = newTable;
        //边界值更新。
        threshold = (int)(newCapacity * loadFactor);
}
//将数据全部重新插入新数组，规则使用新得数组空间值计算。
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;
                    //根据hash值获取对应数组位置。
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
}

4.3 get方法 

//获取key值对应信息。
public V get(Object key) {
        //key为null时候
        if (key == null)
            //直接从0号位置开始查。
            return getForNullKey();
        //计算key值对应hash。
        int hash = hash(key.hashCode());
        //使用indexFor计算出对应table的位置，然后开始遍历。直到找到或者结束。
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
}
//获取key值为null的value。
private V getForNullKey() {
        //先查找0号位，然后依次找next，直到找到key为null的值或键值对为空，返回。
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
}

4.4一些常用的方法

4.4.1 public boolean containsKey(Object key)

将key进行hash计算，然后找到键值对，然后返回结果

4.4.2 public boolean containsValue(Object value)

遍历数组，知道找到value。很费性能。

4.4.3  public void clear()

遍历数组，全部置为null。

4.4.4 public V remove(Object key)

找出对应key，去掉，更新关联值。

4.4.5 public Set<K> keySet()

将整个数组返回，这个Set是单独实现的一个类，里面重新实现了迭代器 ，size，包含，清除，将迭代的结果返回Map的key。其实就是返回了完整的Map内容。没有开辟任何多余空间，所以这个方法会很快。

4.4.6 public Collection<V> values()

这个和上面的一样，直接返回的是Map的整体数据，将Collection实现了迭代器 ，size，包含，清除，将迭代的结果返回Map的value。

 

5.使用的hash算法 

int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
static int hash(int h) {
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
}
static int indexFor(int h, int length) {
        return h & (length-1);
}

计算都是通过hashCode来计算，所以存入HashMap的对象最好不要将hashCode写成一个值。hashCode各个类都有自己的生成方法，似乎Object默认的是内存位置，但是刚刚观察Integer和String都覆写了的。

int占32位，无符号左移20位，空位补0，无符号右移20位。算了，这个二进制运算符要系统的看，先这样把。

6.结束

看到这里都差不多了，主要是理解HashMap的结构和hash算法。

同时产生了两个疑问，先记下来。

疑问一：只实现抽象类AbstractMap不行么？为什么还要implements Map ，不重复吗？

疑问二：transient volatile 这样声明变量是为什么？

 

wdhdmx
关注
专栏目录
详细解析：HashMap源码剖析
m0_68850571的博客
04-23 2620
目录： 一、HashMap概述二、HashMap的数据结构三、HashMap源码分析1、关键属性2、构造方法3、存储数据4、调整大小 5、数据读取 6、HashMap的性能参数 7、Fail-Fast机制 一、HashMap概述 　　HashMap基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序...
HashMap 源码分析
12-22
《HashMap 源码解析——JDK11版本》 HashMap是Java中广泛使用的非同步散列表，其设计和实现是高效且灵活的。在JDK1.8之前，HashMap的底层数据...理解HashMap的源码对于深入学习Java集合框架和数据结构具有重要意义。
16java源码解析-AbstractMap
银银豆豆的博客
09-21 211
其他 源码解析 https://blog.csdn.net/qq_32726809/article/category/8035214  类声明 public abstract class AbstractMap&lt;K,V&gt; implements Map&lt;K,V&gt; implements Map&lt;K,V&gt; 1 实现键值对 2 不能用可变对象作为键 3...
HashMap 源码理解与面试
CrazyApes的博客
12-16 1715
HashMap的源码理解，如果能认真看完，一般的面试应该难不住你了。哈哈
HashMap源码解析超详细
weixin_43691942的博客
04-12 1685
HashMap源码解析超详细
HashMap 源码理解分析和使用
军威兄的博客
09-11 3780
文章目录1. 基本使用——添加、移除元素2. HashMap源码成员变量3. HashMap的所有源码和分析注释4. 补充 1. 基本使用——添加、移除元素 2. HashMap源码成员变量 3. HashMap的所有源码和分析注释 4. 补充 ...
【HashMap】源码理解泳道图
上善若水
12-28 512
hashMap 源码理解
Hashmap源码详解
Vermont_的博客
04-27 2407
1.概述 本篇文章我们来聊聊大家日常开发中常用的一个集合类 -HashMap。HashMap 最早出现在 JDK 1.2中，底层基于散列算法实现。HashMap 允许 null 键和 null 值，在计算哈键的哈希值时，null 键哈希值为 0。HashMap 并不保证键值对的顺序，这意味着在进行某些操作后，键值对的顺序可能会发生变化。另外，需要注意的是，HashMap 是非线程安全类，在多线程环境下可能会存在问题。 2.原理 HashMap 底层是基于散列算法实现，散列算法分为散列再探测和拉链式..
看看HashMap源码理解HashMap的put 方法的执行过程
Josvin
08-04 429
那我们来看一下源码是怎样实现的 public static void main(String[] args) { HashMap<String, Integer> hashMap = new HashMap<>(); hashMap.put("aaaaa", 10); } Ctrl + B 快捷键跳转 先计算key 的 hash 值 hash（key） hash 本质是个数组，为了把元素存进去，就需要把key 值转成数组下标。我们再看源码
HashMap源码解析
moneywenxue的博客
12-10 9055
崇祯五年十二月，余住西湖。大雪三日，湖中人鸟声俱绝。是日更定矣，余拏一小舟，拥毳衣炉火，独往湖心亭看雪。雾凇沆砀，天与云与山与水，上下一白。湖上影子，惟长堤一痕、湖心亭一点，与余舟一芥、舟中人两三粒而已。 到亭上，有两人铺毡对坐，一童子烧酒炉正沸。见余，大喜曰：“湖中焉得更有此人！”拉余同饮。余强饮三大白而别。问其姓氏，是金陵人，客此。及下船，舟子喃喃曰：“莫说相公痴，更有痴似相公者！” ——张岱《湖心亭看雪》 一、前言 本文分析HashMap源码和多线程下HashMap产生死锁的过程。后一篇文章.
hashMap1.8源码
01-19
HashMap是Java编程语言中最常用的集合类之一，它提供了一种基于...通过深入理解这些细节，开发者可以更好地利用HashMap，避免潜在的问题，并优化性能。对于学习者来说，阅读源码并结合实践是掌握HashMap的最好方式。
深入理解Java之HashMap源码剖析
08-31
深入理解Java中的HashMap源码，有助于我们更好地掌握这个常用数据结构的工作原理。HashMap是Java集合框架的重要组成部分，它实现了Map接口，提供了一种快速查找、插入和删除元素的方式。本文将详细解析HashMap的内部...
HashMap源码阅读
12-21
HashMap是Java编程语言中最常用的集合类之一，它提供了一种基于键值对的高效存储和检索数据...在面试中，理解HashMap的源码细节，特别是其数据结构和哈希冲突处理，通常是考察候选人对Java集合框架掌握程度的重要指标。
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 519
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1016
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
qq_36400213的博客
11-04 595
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 388
默认对常规Session的理解和使用，如何使用Set-Cookie。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 205
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值