分析轮子- HashMap.java 之概念梳理

Posted godtrue

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了分析轮子- HashMap.java 之概念梳理相关的知识,希望对你有一定的参考价值。

注:玩的是JDK1.7版本

一:还是原来的风格,先上一下类的继承关系图,这样能够比较清楚的知道此类的相关特性

二:HashMap.java 的代码比较难看,所以,我看了几天,写的话也分开来写,这样能表达的更清晰,HashMap.java 的底层数据结构,本质是单向链表数组,如下所示是单向链中节点的结构信息

三:既然 HashMap.java 的底层数据结构是单向链表数组,那么我们便可以想象一下数组和单向链表这两种数据结构的特点,然后再回头想想 HashMap.java 的实现,然后再看源码就更容易理解了,如下所示是可能的结构样子。

1)通常应该是如下所示的结构形式,哈希值比较均匀,部分存在冲突

2)极端情况可能是如下所示的结构形式,存在大量冲突,单向链表数组 变成了 单向链表

3)极端情况可能是如下所示的结构形式,没有任何冲突,单向链表数组 变成了 简单的数组

四:看完如上 HashMap.java 的底层数据结构的可能呈现的样子之后,我们再看一下 HashMap.java 中的有关属性,个人感觉可能的结构了解后,更容易理解这些属性的本质,注意:HashMap.java 的特点是可动态扩容哈!

1)HashMap的默认初始化容量(16),表示HashMap当前最多能够装载16个元素,注意:必须是2的幂次方

    /**
     * The default initial capacity - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

2)HashMap的最大容量 2的30次方=1073741824

    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

3)HashMap默认的装载因子(0.75f),用于衡量HashMap满的程度,0.75=3/4,换言之当HashMap中的元素超过当前容量的3/4的时候,HashMap就会进行动态的扩容

    /**
     * The load factor used when none specified in constructor.
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

4)HashMap没有真正放置元素时,是一个空数组

    /**
     * An empty table instance to share when the table is not inflated.
     */
    static final Entry<?,?>[] EMPTY_TABLE = {};

5)HashMap没有真正放置元素时,是一个空数组,注意:HashMap的容量长度必须是2的幂次方

    /**
     * The table, resized as necessary. Length MUST Always be a power of two.
     */
    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

6)HashMap中 key-value mapping 映射对的个数

    /**
     * The number of key-value mappings contained in this map.
     */
    transient int size;

7)HashMap 动态扩容的临界值,每当 size>threshold 的时候,HashMap 就会动态扩容了,threshold = capacity * load factor

    /**
     * The next size value at which to resize (capacity * load factor).
     * @serial
     */
    // If table == EMPTY_TABLE then this is the initial capacity at which the
    // table will be created when inflated.
    int threshold;

8)装载因子,用于 HashMap 是否进行动态扩容计算的变量之一,默认值是0.75f,如无必要通常不必改变

    /**
     * The load factor for the hash table.
     *
     * @serial
     */
    final float loadFactor;

 五:实验实验,玩一把,看看什么情况

1)结论性信息的都放在了代码注释之中,如下所示(可以自己动手调整一下参数配置,跑跑看)

/**
 * @description:玩一把HashMap
 * @author:godtrue
 * @create:2018-09-28
 */
public class TestMap {

    /**
     * 开始循环的基数
     */
    public static final int START_LOOP=1;

    /**
     * 结束循环的基数
     */
    public static final int END_LOOP=17;

    /**
    *
    *@description: 测试入口,主方法
    *@param args
    *@return: void
    *@author: godtrue
    *@createTime: 2018-09-28 9:53
    *@version: v1.0
    */
    public static void main(String[] args) {
        /**
         * 此处可以调用不同的构造方法来观察,HashMap 的容量、装载因子、扩容临界值、K-V映射对的个数等重点参数之间的关系
         * 重点强调一次
         * 1:capacity 容量——HashMap最多能装载元素个数
         * 2:loadFactor 装载因子——表示HashMap满的程度,判断HashMap是否扩容的变量之一
         * 3:threshold 扩容临界值——判断HashMap是否扩容的标准( threshold = capacity * loadFactor )
         * 4:size HashMap 已经装载的元素个数——已经转载进入HashMap的 K-V mapping 映射对的个数
         *
         * 5:HashMap 能够动态扩容,当 size > threshold 时 HashMap,便会自动库容,每次扩容的长度是原来 容量 的 2 倍
         * 6:HashMap 的 key 和 value 都可以为 null
         * 7:HashMap 是非线程安全的
         *
         */
        //Map hashMap = new HashMap<String,String>();
        Map hashMap = new HashMap<String,String>(1);
        for(int i = TestMap.START_LOOP;i<TestMap.END_LOOP;i++){
            /**
             * 此处可以控制 key 值,来观察一下运行的情况
             */
            //hashMap.put(null,"i am godtrue"+i);
            //hashMap.put("godtrue","i am godtrue"+i);
            hashMap.put("godtrue"+i,"i am godtrue"+i);
            printMapInfo(hashMap,i);
        }
        System.out.println("hashMap is : "+hashMap);
    }

    /**
    *
    *@description: 将 Map 的参数信息打印到控制台,主要是打印 容量、装载因子、扩容临界值、K-V映射对的个数 等参数信息
    *@param map
    *@param i
    *@return: void
    *@author: godtrue
    *@createTime: 2018-09-28
    *@version: v1.0
    */
    private synchronized static void printMapInfo(Map map,int i){
        System.out.println("添加第 "+i +" 个元素后");
        printMapMethodInfo(map,"capacity");
        printMapFieldInfo(map,"loadFactor");
        printMapFieldInfo(map,"threshold");
        printMapFieldInfo(map,"size");
        System.out.println("***********************************************\\n");
    }

    /**
    *
    *@description:  将 Map 的属性信息打印到控制台,主要是打印 装载因子、扩容临界值、K-V映射对的个数 等参数信息
    *@param map
    *@param property
    *@return: void
    *@author: godtrue
    *@createTime: 2018-09-28
    *@version: v1.0
    */
    private static void printMapFieldInfo(Map map,String property){
        try {
            Class<?> mapType = map.getClass();
            Field field = mapType.getDeclaredField(property);
            field.setAccessible(true);
            System.out.println(field +" : "+ field.get(map));
        }catch (Exception e){
            System.err.println("e is :"+e);
            e.printStackTrace();
        }
    }

    /**
    *
    *@description: 将 Map 的方法信息打印到控制台,主要是想打印 容量 的信息
    *@param map
    *@param property
    *@return: void
    *@author: godtrue
    *@createTime: 2018-09-28
    *@version: v1.0
    */
    private static void printMapMethodInfo(Map map,String property){
        try {
            Class<?> mapType = map.getClass();
            Method method = mapType.getDeclaredMethod(property);
            method.setAccessible(true);
            System.out.println(method +" : "+ method.invoke(map));
        }catch (Exception e){
            System.err.println("e is :"+e);
            e.printStackTrace();
        }
    }
}

 2)仔细观察如下日志,可以印证上述代码注释中的部分结论,注意:请重点关注 capacity、loadFactor、threahold、size之间的变化关系

添加第 1 个元素后
int java.util.HashMap.capacity() : 1
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 0
transient int java.util.HashMap.size : 1
***********************************************

添加第 2 个元素后
int java.util.HashMap.capacity() : 2 //扩容
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 1
transient int java.util.HashMap.size : 2
***********************************************

添加第 3 个元素后
int java.util.HashMap.capacity() : 4 //扩容
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 3
transient int java.util.HashMap.size : 3
***********************************************

添加第 4 个元素后
int java.util.HashMap.capacity() : 4
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 3
transient int java.util.HashMap.size : 4
***********************************************

添加第 5 个元素后
int java.util.HashMap.capacity() : 8 //扩容
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 6
transient int java.util.HashMap.size : 5
***********************************************

添加第 6 个元素后
int java.util.HashMap.capacity() : 8
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 6
transient int java.util.HashMap.size : 6
***********************************************

添加第 7 个元素后
int java.util.HashMap.capacity() : 8
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 6
transient int java.util.HashMap.size : 7
***********************************************

添加第 8 个元素后
int java.util.HashMap.capacity() : 8
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 6
transient int java.util.HashMap.size : 8
***********************************************

添加第 9 个元素后
int java.util.HashMap.capacity() : 16 //扩容
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 12
transient int java.util.HashMap.size : 9
***********************************************

添加第 10 个元素后
int java.util.HashMap.capacity() : 16
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 12
transient int java.util.HashMap.size : 10
***********************************************

添加第 11 个元素后
int java.util.HashMap.capacity() : 16
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 12
transient int java.util.HashMap.size : 11
***********************************************

添加第 12 个元素后
int java.util.HashMap.capacity() : 16
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 12
transient int java.util.HashMap.size : 12
***********************************************

添加第 13 个元素后
int java.util.HashMap.capacity() : 32 //扩容
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 24
transient int java.util.HashMap.size : 13
***********************************************

添加第 14 个元素后
int java.util.HashMap.capacity() : 32
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 24
transient int java.util.HashMap.size : 14
***********************************************

添加第 15 个元素后
int java.util.HashMap.capacity() : 32
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 24
transient int java.util.HashMap.size : 15
***********************************************

添加第 16 个元素后
int java.util.HashMap.capacity() : 32
final float java.util.HashMap.loadFactor : 0.75
int java.util.HashMap.threshold : 24
transient int java.util.HashMap.size : 16
***********************************************

hashMap is : {godtrue4=i am godtrue4, godtrue5=i am godtrue5, godtrue2=i am godtrue2, godtrue3=i am godtrue3, godtrue8=i am godtrue8, godtrue9=i am godtrue9, godtrue6=i am godtrue6, godtrue7=i am godtrue7, godtrue1=i am godtrue1, godtrue10=i am godtrue10, godtrue12=i am godtrue12, godtrue11=i am godtrue11, godtrue14=i am godtrue14, godtrue13=i am godtrue13, godtrue16=i am godtrue16, godtrue15=i am godtrue15}

Process finished with exit code 0

 六:几个为什么?

1)为什么 HashMap 的默认容量是 16, 并且强调容量必须是 2 的幂次方呢?

      HashMap 的容量必须是 2 的幂次方,主要是出于性能的考虑,可以使用 位于运算 来计算单向链表数组的下标位置

      详情可参考 

     http://www.hollischuang.com/archives/2091

     http://www.cnblogs.com/chenssy/p/3521565.html

     https://blog.csdn.net/justloveyou_/article/details/62893086

     默认值为什么是16呢?

     首先,16 是 2的4次方,符合容量是 2 的幂次方的强性规定,其次,我猜测 16 可能是一个样本比较集中的 HashMap的容量

2)为什么 HashMap 的默认装载因子是 0.75f,并且不建议自定义呢?

      HashMap 的默认装载因子是0.75f,主要是时间和空间成本上一种折衷。

      详情可参考

      http://alex09.iteye.com/blog/539545/

3)为什么 HashMap 在扩容的时候,总是扩大原来容量的 2 倍呢?

      首先,容量扩大 2 倍后,仍然符合容量是 2 的幂次方的强性规定(注意:容量是2的幂次方),其次,同样是出于性能考虑,直接通过左移移位便可实现

七)本篇,编写的过程中参看了 http://www.hollischuang.com/archives/2416

 

以上是关于分析轮子- HashMap.java 之概念梳理的主要内容,如果未能解决你的问题,请参考以下文章

Java面试技巧之MySQL问题梳理

Java面向对象-面向对象编程之基本概念

通用工业协议(CIP)形式化的安全分析(前期概念的梳理)

Android Gradle的基本概念梳理

OpenStack入门之核心组件梳理——Glance篇

app爬虫--mitmproxy用法梳理