Map集合体系及HashMap源码分析

最新推荐文章于 2022-04-23 08:45:00 发布

小玉程序员

最新推荐文章于 2022-04-23 08:45:00 发布

阅读量89

点赞数

本文链接：https://blog.csdn.net/c546592321/article/details/121509295

版权

集合框架专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的Map集合，包括HashMap的特性、常用方法及其实现原理。通过示例展示了Map的两种遍历方式：KeySet和EntrySet。还深入解析了HashMap的源码，特别是put方法的实现，包括初始容量、最大容量、负载因子以及何时转换为红黑树的条件。最后探讨了HashMap在JDK1.8后采用红黑树提高效率的策略。

摘要由CSDN通过智能技术生成

Map集合

Map体系结构
在这里插入图片描述

Map特点

map集合用来存储key-value"键值对"
键（key）的值无序不可重复
值（value）的值无序可重复

Map集合方法

void clear()
从此映射中移除所有映射关系（可选操作）。
boolean containsKey(Object key)
如果此映射包含指定键的映射关系，则返回 true。
boolean containsValue(Object value)
如果此映射将一个或多个键映射到指定值，则返回 true。
Set<Map.Entry<K,V>> entrySet()
返回此映射中包含的映射关系的 Set 视图。
boolean equals(Object o)
比较指定的对象与此映射是否相等。
V get(Object key)
返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
int hashCode()
返回此映射的哈希码值。
boolean isEmpty()
如果此映射未包含键-值映射关系，则返回 true。
Set keySet()
返回此映射中包含的键的 Set 视图。
V put(K key, V value)
将指定的值与此映射中的指定键关联（可选操作）。
void putAll(Map<? extends K,? extends V> m)
从指定映射中将所有映射关系复制到此映射中（可选操作）。
V remove(Object key)
如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
int size()
返回此映射中的键-值映射关系数。
Collection values()
返回此映射中包含的值的 Collection 视图。

package com.design;

import java.util.HashMap;

public class MapDemo {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<Integer, String>();
        map.put(1,"张三");
        map.put(2,"李四");
        map.put(3,"李四");
        System.out.println(map.entrySet());
        map.remove(1);
        System.out.println(map);

    }
}

Map集合的两种遍历方式

KeySet方式
EntrySet方式

HashMap<Integer, String> map = new HashMap<Integer, String>();
        map.put(1,"张三");
        map.put(2,"李四");
        map.put(3,"李四");
        //1利用keySet遍历
        for (Integer key:
             map.keySet()) {
            System.out.println(key+"="+map.get(key));
        }
        //2利用entrySet遍历
        for (Map.Entry<Integer,String> m:
             map.entrySet()) {
            System.out.println(m);
        }

图解
在这里插入图片描述
显而易见的是，使用下面的方法不需要每次都再调用get方法，执行效率更高

HashMap源码分析

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    static final int MAXIMUM_CAPACITY = 1 << 30;

    static final float static final float DEFAULT_LOAD_FACTOR = 0.75f;

 
    static final int TREEIFY_THRESHOLD = 8;

  
    static final int UNTREEIFY_THRESHOLD = 6;

    static final int MIN_TREEIFY_CAPACITY = 64;

DEFAULT_INITIAL_CAPACITY 为默认初始化容量16
MAXIMUM_CAPACITY为最大容量2^30次方
DEFAULT_LOAD_FACTOR为默认加载百分比，数值为0.75，意为当前容量超过最大容量的百分之75时便进行扩容
TREEIFY_THRESHOLD = 8意为当链表长度为8时我们便把链表转换为红黑树，来增加效率;
UNTREEIFY_THRESHOLD = 6，意为当红黑树长度小于6时便转换为链表;
static final int MIN_TREEIFY_CAPACITY = 64，意为转换为红黑树的最小数组长度为64;
TREEIFY_THRESHOLD
UNTREEIFY_THRESHOLD
MIN_TREEIFY_CAPACITY
三个常量均为JDK1.8之后引入，因为1.8之后才选用红黑树来处理元素过多的情况。

我们点开put方法的源码发现其封装了putVal方法

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

我们点开putVal方法

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; 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) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        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)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }