【Java集合】HashMap

最新推荐文章于 2024-06-21 17:14:47 发布
最新推荐文章于 2024-06-21 17:14:47 发布
阅读量745 收藏
点赞数
分类专栏： Java集合 文章标签： java 链表 map android 移动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Guxiaodong_single/article/details/121828171
版权

继承结构

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

数据存储结构

数组 +（单项链表或红黑树)，链表深度大于8时，会将链表存储转化为红黑树存储
(线程不安全)

写在前面的一些方法、说明
     // Returns a power of two size for the given target capacity.
     //cap = 0  return 1
     // cap = 1  return 1
     // cap = 2  return 2
     // cap = 3  return 4
     // cap = 4  return 4
     // 4 < cap <= 8  return 8
     // 8 < cap <= 16  return 16
     // cap > 16   return 32
     // cap <= 32  return 32
     // cap > 32   return 64
     //        ····
   
    // cap = 12
    // cap = 33
    static final int tableSizeFor(int cap) {
        // n = 11 -> 0000 1011
        // n = 32 -> 0010 0000
        int n = cap - 1;
        // n >>> 1 -> 0000 0101,n | n >>> 1 -> 0000 1111
        // n >>> 1 -> 0001 0000,n | n >>> 1 -> 0011 0000
        n |= n >>> 1;
        // n >>> 2 -> 0000 0011,n | n >>> 2 -> 0000 1111
        // n >>> 2 -> 0000 1100,n | n >>> 2 -> 0011 1100
        n |= n >>> 2;
        // ...
        // n >>> 4 -> 0000 1111,n | n >>> 4 -> 0011 1111
        n |= n >>> 4;
        // ...
        // n >>> 8 -> 0000 0000,n | n >>> 8 -> 0011 1111
        n |= n >>> 8;
        // ...
        // ...
        n |= n >>> 16;
        // n = 15
        // n = 63
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
        // return n = 16
        // return n = 64
    }
  • final Node<K, V>[] resize() 扩容，返回扩容后的新数组
    final Node<K, V>[] resize() {
        Node<K, V>[] oldTab = table;
        // 老table的容量
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {// 老table中有值
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) {
                newThr = oldThr << 1; // double threshold
            }
        } else if (oldThr > 0) { // initial capacity was placed in threshold
            newCap = oldThr;
        } else { // 使用无参的构造方法，第一次put数据才会走到这里     // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY; // 16
            newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 12
        }
        if (newThr == 0) {
            float ft = (float) newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ? (int) ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes", "unchecked"})
        Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
        table = newTab;
        // 数据转移
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) { // 遍历老table数组
                Node<K, V> e;
                if ((e = oldTab[j]) != null) { // 当前位置有数据
                    oldTab[j] = null;// 释放
                    if (e.next == null) // 当前位置链表只有一个节点
                        newTab[e.hash & (newCap - 1)] = e; // 重新hash，并入新数组
                    else if (e instanceof TreeNode) // 为红黑树的情况
                        ((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
                    else { // preserve order ：保持顺序
                        Node<K, V> loHead = null, loTail = null;
                        Node<K, V> hiHead = null, hiTail = null;
                        Node<K, V> next;
                        // 将同一桶中的节点按着 e.hash & oldCap 是否为0进行分割，分成两个链表完成rehash
                        do {
                            next = e.next;
                            // 根据算法 e.hash & oldCap判断节点位置rehash后位置是否改变
                            // 最高位为0，索引不变的链表
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            } else {
                                // 最高位为1，索引发生改变的链表
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) { // 愿bucket位置的尾指针不为null
                            loTail.next = null; // 链表最后需要有个null节点
                            newTab[j] = loHead; // 链表头指针放在新链表的原下标出
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            // rehash后的节点新的位置一定是原来基础上加上oldCap
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }
  • final void treeifyBin(Node<K, V>[] tab, int hash)树化：单链表>>>双向链表>>>红黑树
    final void treeifyBin(Node<K, V>[] tab, int hash) {
        int n, index;
        Node<K, V> e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K, V> hd = null, tl = null;
            do {// 遍历单项链表转为双向链表
                TreeNode<K, V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab); // 双向链表转为红黑树
        }
    }
  • final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) 添加元素，返回前一个值，如果没有返回null
    // Implements Map.put and related methods
     // @param hash         hash for key  - key的hash值
     // @param key          the key        - key值
     // @param value        the value to put  - value值
     // @param onlyIfAbsent if true, don't change existing value  - 如果是true，同key不会被新值覆盖
     // @param evict        if false, the table is in creation mode.
     // @return previous value, or null if none
     //
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
        Node<K, V>[] tab;
        Node<K, V> p; // hash计算位置的node
        int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length; // 初始化table
        if ((p = tab[i = (n - 1) & hash]) == null) // 当前位置没有数据，则新建赋值
            tab[i] = newNode(hash, key, value, null);
        else { // 当前位置存在数据
            Node<K, V> e; // 当前key对应的node
            K k;
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode) // 如果当前位置的为红黑树
                e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) { // 循环找key的hash值&&key对应的node，如果不存在，则创建新node
                    if ((e = p.next) == null) { // 该位置链表没有找到对应key的node
                        p.next = newNode(hash, key, value, null);//创建新node，放在链表队尾
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st 
                            treeifyBin(tab, hash); // 链表深度>=8，转为红黑树存储
                        break;
                    }
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null) // 根据onlyIfAbsent判断是否覆盖旧值
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }
  • final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict)
    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();
        if (s > 0) {
            if (table == null) { // pre-size 
                // 初始化阀值
                float ft = ((float) s / loadFactor) + 1.0F;
                int t = ((ft < (float) MAXIMUM_CAPACITY) ?
                        (int) ft : MAXIMUM_CAPACITY);
                if (t > threshold)
                    threshold = tableSizeFor(t);
            } else if (s > threshold)
                resize(); // 扩容
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) { // 遍历put单个元素
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }
  • final Node<K, V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) // 返回移除的节点对象
    final Node<K, V> removeNode(int hash, Object key, Object value,
                                boolean matchValue, boolean movable) {
        Node<K, V>[] tab;
        Node<K, V> p;
        int n, index;
        if ((tab = table) != null && (n = tab.length) > 0 &&
                (p = tab[index = (n - 1) & hash]) != null) { // 当前位置有节点
            Node<K, V> node = null, e;
            K k;
            V v;
            if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
                // 当前位置第一个节点就是目标值
                node = p;
            else if ((e = p.next) != null) {
                if (p instanceof TreeNode)// 当前位置存储为红黑树的情况
                    node = ((TreeNode<K, V>) p).getTreeNode(hash, key);
                else {
                    // 遍历链表匹配节点 始终保持p.next = e
                    do {
                        if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
            // 移除节点
            // matchValue 如果为true，移除当前节点还需要匹配value值
            if (node != null && (!matchValue || (v = node.value) == value ||
                    (value != null && value.equals(v)))) {
                if (node instanceof TreeNode) // 红黑树移除节点
                    ((TreeNode<K, V>) node).removeTreeNode(this, tab, movable);
                else if (node == p) // 当前位置第一个节点就是目标值的情况
                    tab[index] = node.next;
                else // 移除node这个节点
                    p.next = node.next;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node; // 返回移除的节点对象
            }
        }
        return null;
    }
  • final Node<K, V> getNode(int hash, Object key)通过hash、key匹配查找node
    final Node<K, V> getNode(int hash, Object key) {
        Node<K, V>[] tab;
        Node<K, V> first, e;
        int n;
        K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
                (first = tab[(n - 1) & hash]) != null) { // 保证table中有数据，且对应的hash值有数据
            if (first.hash == hash && // always check first node（先匹配first变量节点）
                    ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)// 红黑树查找
                    return ((TreeNode<K, V>) first).getTreeNode(hash, key);
                do { // 链表查找
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

一、增

  • public V put(K key, V value)
   public V put(K key, V value) {
       return putVal(hash(key), key, value, false, true);
   }
  • public void putAll(Map<? extends K, ? extends V> m)
    public void putAll(Map<? extends K, ? extends V> m) {
        putMapEntries(m, true);
    }
  • public V putIfAbsent(K key, V value)如果key对应的value不为null，则不会覆盖旧值
    @Override
    public V putIfAbsent(K key, V value) {
        return putVal(hash(key), key, value, true, true);
    }

二、删

  • public V remove(Object key)返回删除的节点的value值
    public V remove(Object key) {
        Node<K, V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
                null : e.value;
    }
  • public boolean remove(Object key, Object value) 返回值表示是否查找对应的node
    @Override
    public boolean remove(Object key, Object value) {
        return removeNode(hash(key), key, value, true, true) != null;
    }

三、改

  • public V put(K key, V value)如果key存在，修改value
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
  • public V replace(K key, V value)查找替换value，返回旧值value or null
   @Override
    public V replace(K key, V value) {
        Node<K, V> e;
        if ((e = getNode(hash(key), key)) != null) { // 只匹配key查找
            V oldValue = e.value;
            e.value = value;// 替换
            afterNodeAccess(e);
            return oldValue; // 返回旧value
        }
        return null;
    }
  • public boolean replace(K key, V oldValue, V newValue)查找替换value，返回值表示是否查找到元素
    @Override
    public boolean replace(K key, V oldValue, V newValue) {
        Node<K, V> e;
        V v;
        if ((e = getNode(hash(key), key)) != null &&
                ((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) { // 同时匹配key 和 value
            e.value = newValue;
            afterNodeAccess(e);
            return true; 
        }
        return false;
    }

四、查

  • public boolean containsKey(Object key)通过key是否能查找到元素，返回值表示通过key是否可以查找到node
    public boolean containsKey(Object key) {
        return getNode(hash(key), key) != null;
    }
  • public boolean containsValue(Object value)遍历table每个位置，返回值表示是否查找到value
    public boolean containsValue(Object value) {
        Node<K, V>[] tab;
        V v;
        if ((tab = table) != null && size > 0) {
            // TreeNode中的包含了2种数据结构，双向链表和红黑树
            for (int i = 0; i < tab.length; ++i) {
                // 这种链表遍历方式可以完全遍历到所有元素
                for (Node<K, V> e = tab[i]; e != null; e = e.next) {
                    if ((v = e.value) == value ||
                            (value != null && value.equals(v)))
                        return true;
                }
            }
        }
        return false;
    }

【感谢】
HashMap源码解析——Java 8系列之重新认识HashMap
HashMap源码解析——一文读懂HashMap

Guxxxd
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java集合之HashMap
初心不忘、始终方得
04-06 1413
学而时习之，不亦乐乎
Java集合 - HashMap
飞鱼的博客
01-01 855
本篇文章介绍 Java 集合中的 HashMap。 1、HashMap 的底层存储结构； 2、HashMap 的新增操作的处理逻辑； 3、HashMap 的数组扩容机制； 4、HashMap 的查询操作的处理逻辑；
JAVA集合：HashMap
栗筝i的博客
10-14 3931
本篇内容包括：HashMap 概述、HashMap 底层数据结构、HashMap 扩容机制、HashMap 线程不安全性以及 HashMap 的使用。
Java集合之一—HashMap
热门推荐
深入浅出学JAVA
11-02 60万+
深入浅出学Java——HashMap 哈希表（hash table） 也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，本文会对java集合框架中的对应实现HashMap的实现原理进行讲解，然后会对JDK7的HashMap源码进行分析。 一、什么是哈希表 在讨论哈希表之前，我们先大概了解下其他数据结构在新增，...
Java集合 —— HashMap原理解析
m0_56602092的博客
04-28 3675
一、HashMap是什么 HashMap是一个存储key-value键值对的哈希表，表中每个元素的key都是唯一的（通过equals方法判断），查询时通过key的hashcode值即可定位到元素的存储地址，因此HashMap在理想情况下查询时间复杂度为O(1)。 1. 存储下标计算方法 HashMap底层通过Entry数组来存储元素，插入元素和查询元素时首先需要计算元素在数组中的存储下标，方法如下： 1. 通过key的hashCode()方法获取其hashcode值 2. 将这个hashcode值再通过h
在java集合HashMap中如何替换某一个键值
19.2.04.157N的博客
08-10 2063
在java集合HashMap中如何替换某一个键值
java集合超详解
feiyan的博客
08-03 45万+
一、集合大纲 1.集合和数组的区别： 2.Collection集合的方法： 3.常用集合的分类： Collection 接口的接口 对象的集合（单列集合） ├——-List 接口：元素按进入先后有序保存，可重复 │—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全 │—————-├ ArrayList 接口...
Java集合HashMap初始容量与容量大小
靖节先生的博客
11-22 3139
HashMap 初试容量 与 的容量大小 这是两个问题 为什么设置初始容量 初始容量多大合适 第一个问题：为什么设置初始容量 这个答案其实通过阅读源码也可以得到。简单来说就是避免扩容带来的效率问题。扩容机制具体详见源码。 在初始化 HashMap 的时候，应该尽量指定其大小。尤其是当你已知 map 中存放的元素个数时。（《阿里巴巴 Java 开发规约》） 第二个问题：初始容量多大合适 那么，既然建议我们集合初始化的时候，要指定初始值大小，那么我们创建 HashMap 的时候，到底指定多少合适呢？ 有些人
Java中HashMap的用法
eck_燃的博客
03-19 9万+
HashMap 学习java基础的时候对map不熟悉，再加上图算法经常用到这个结构来存储，特此加一篇文章来介绍Map import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map.Entry; public class HashMap { publi......
Java集合 HashMap底层实现详解
奔跑的蜗牛
05-20 3683
在前面几篇文章中，我们也已经学习了关于List、Set的常用集合，今天学习最常用的Map集合：HashMap。 在学习HashMap之时，首先应该清楚明白： HashMap的工作原理： HashMap基于hashing原理，通过put()和get()方法存储和获取对象。当我们将键值对传递给put()方法时，它调用对象的hashCode()方法来计算hashCode，然后找到bucket位置来存储对...
Java集合之HashMap用法详解
08-30
Java集合之HashMap用法详解 Java集合之HashMap用法详解主要介绍了Java集合之HashMap用法，结合实例形式分析了java map集合中HashMap定义、遍历等相关操作技巧。 HashMap概述 HashMap是Java集合框架中最常用的Map...
Java集合系列之HashMap源码分析
08-27
Java集合系列之HashMap源码分析 Java集合系列之HashMap源码分析是Java集合系列中的一篇非常重要的文章，它详细介绍了Java集合系列之HashMap源码，具有很高的参考价值。下面我们将对HashMap源码进行详细的分析。 ...
java集合-HashMap的使用
06-14
HashMap是一种常用的哈希表实现，用于存储键值对。它实现了Map接口，并且使用键的哈希值来快速定位和访问值。
Java集合框架HashMap说明.doc
05-10
Java集合框架中的HashMap是开发人员经常使用的数据结构，它是一个基于哈希表的Map接口实现，以键值对（key-value）的形式存储数据。HashMap的核心特点是通过哈希算法快速定位数据，实现O(1)的平均查找速度。下面将...
java遍历HashMap简单的方法
09-03
在Java编程中，HashMap是一种常用的集合类，它用于存储键值对数据。遍历HashMap是开发者经常遇到的任务，尤其在处理数据操作时。本篇文章将详细介绍如何使用简单的方法来遍历HashMap，通过实例代码帮助理解。 ...
日常工作记录目录
与海
06-21 52
EasyExcel实现二维码下载与展示
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 609
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 690
JSON，Ajax
Homebrew使用
最新发布
gghh2015的博客
06-21 145
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
java集合和hashmap
09-19
HashMap是Java集合框架中的一个类，它实现了Map接口。HashMap使用哈希表来存储键值对，提供了快速的插入、查找和删除操作。它允许键和值为null，并且不保证元素的顺序。 以下是HashMap的一些常用操作： - 添加元素...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值