HashMap扩容机制及源码分析

待修改。。

一、扩容机制

HashMap是没有进行初始化容量，也就是现在是一个空的HashMap（容量为0）,这是因为HashMap使用的懒加载机制。
HashMap就使用默认的初始化容量，也就是16.
存储大容量数据的时候，最好预先指定hashmap的size为2的整数次幂次方。
就算不指定的话，也会以大于且最接近指定值大小的2次幂来初始化的。
测试HashMap扩容机制：loadFactor的默认值为0.75，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作。

二、代码测试

package com.god.genius.basic.collection.map;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Author libusi
 * @Date 2019/9/26 19:39
 */
public class HashMapTest {
    public static void main(String[] args) {
        List<Map<String, Long>> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            HashMap<String, Long> map = new HashMap<>();
            Long aLong = demo0();
            Long aLong1 = demo1();
            Long aLong2 = demo2();
            Long aLong3 = demo3();
            Long aLong4 = demo33();
            Long aLong5 = demo4();
            Long aLong6 = demo5();
            Long aLong7 = demo6();
            Long aLong8 = demo7();
            Long aLong9 = demo8();
            Long aLong10 = demo9();
            Long aLong11 = demo10();
            Long aLong12 = demo11();
            map.put("aLong", aLong);
            map.put("aLong1", aLong1);
            map.put("aLong2", aLong2);
            map.put("aLong3", aLong3);
            map.put("aLong4", aLong4);
            map.put("aLong5", aLong5);
            map.put("aLong6", aLong6);
            map.put("aLong7", aLong7);
            map.put("aLong8", aLong8);
            map.put("aLong9", aLong9);
            map.put("aLong10", aLong10);
            map.put("aLong11", aLong11);
            map.put("aLong12", aLong12);
            list.add(map);
        }
        Long aLong = 0L;
        Long aLong1 = 0L;
        Long aLong2 = 0L;
        Long aLong3 = 0L;
        Long aLong4 = 0L;
        Long aLong5 = 0L;
        Long aLong6 = 0L;
        Long aLong7 = 0L;
        Long aLong8 = 0L;
        Long aLong9 = 0L;
        Long aLong10 = 0L;
        Long aLong11 = 0L;
        Long aLong12 = 0L;

        for (Map<String, Long> map : list) {
            aLong = map.get("aLong") + aLong;
            aLong1 = map.get("aLong1") + aLong1;
            aLong2 = map.get("aLong2") + aLong2;
            aLong3 = map.get("aLong3") + aLong3;
            aLong4 = map.get("aLong4") + aLong4;
            aLong5 = map.get("aLong5") + aLong5;
            aLong6 = map.get("aLong6") + aLong6;
            aLong7 = map.get("aLong7") + aLong7;
            aLong8 = map.get("aLong8") + aLong8;
            aLong9 = map.get("aLong9") + aLong9;
            aLong10 = map.get("aLong10") + aLong10;
            aLong11 = map.get("aLong11") + aLong11;
            aLong12 = map.get("aLong12") + aLong12;
        }

        System.out.println(aLong);
        System.out.println(aLong1);
        System.out.println(aLong2);
        System.out.println(aLong3);
        System.out.println(aLong4);
        System.out.println(aLong5);
        System.out.println(aLong6);
        System.out.println(aLong7);
        System.out.println(aLong8);
        System.out.println(aLong9);
        System.out.println(aLong10);
        System.out.println(aLong11);
        System.out.println(aLong12);


    }

    private static Long demo0() {
        long l = System.currentTimeMillis();
        HashMap<Integer, Integer> map1 = new HashMap<>();
        for (int i = 1; i <= 10000000; i++) {
            map1.put(i, i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("热身：" + (l2 - l));
        return (l2 - l);
    }


    private static Long demo1() {
        long l = System.currentTimeMillis();
        HashMap<Integer, Integer> map1 = new HashMap<>();
        for (int i = 1; i <= 10000000; i++) {
            map1.put(i, i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("无参数：" + (l2 - l));
        return (l2 - l);
    }


    private static Long demo2() {
        long l = System.currentTimeMillis();
        HashMap<Integer, Integer> map = new HashMap<>(127);
        for (int i = 1; i <= 10000000; i++) {
            map.put(i, i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("小参数127：" + (l2 - l));
        return (l2 - l);
    }

    private static Long demo3() {
        long l = System.currentTimeMillis();
        HashMap<Integer, Integer> map = new HashMap<>(1023);
        for (int i = 1; i <= 10000000; i++) {
            map.put(i, i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("小参数1023：" + (l2 - l));
        return (l2 - l);
    }

    private static Long demo33() {
        long l = System.currentTimeMillis();
        HashMap<Integer, Integer> map = new HashMap<>(524288);
        for (int i = 1; i <= 10000000; i++) {
            map.put(i, i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("小参数524288：" + (l2 - l));
        return (l2 - l);
    }


    private static Long demo4() {
        long l = System.currentTimeMillis();
        HashMap<Integer, Integer> map2 = new HashMap<>(5000000);
        for (int i = 1; i <= 10000000; i++) {
            map2.put(i, i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("参数一半：" + (l2 - l));
        return (l2 - l);
    }


    private static Long demo5() {
        long l = System.currentTimeMillis();
        HashMap<Integer, Integer> map5 = new HashMap<>(7500000);
        for (int i = 1; i <= 10000000; i++) {
            map5.put(i, i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("扩容一次1：" + (l2 - l));
        return (l2 - l);
    }


    private static Long demo6() {
        long l = System.currentTimeMillis();
        HashMap<Integer, Integer> map5 = new HashMap<>(8388600);
        for (int i = 1; i <= 10000000; i++) {
            map5.put(i, i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("扩容一次2：" + (l2 - l));
        return (l2 - l);
    }

    private static Long demo7() {
        long l = System.currentTimeMillis();
        HashMap<Integer, Integer> map44 = new HashMap<>(8388608);
        for (int i = 1; i <= 10000000; i++) {
            map44.put(i, i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("扩容一次3：" + (l2 - l));
        return (l2 - l);
    }

    private static Long demo8() {
        long l = System.currentTimeMillis();
        HashMap<Integer, Integer> map3 = new HashMap<>(10240000);
        for (int i = 1; i <= 10000000; i++) {
            map3.put(i, i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("扩容一次4：" + (l2 - l));
        return (l2 - l);
    }

    private static Long demo9() {
        long l = System.currentTimeMillis();
        HashMap<Integer, Integer> map4 = new HashMap<>(10240001);
        for (int i = 1; i <= 10000000; i++) {
            map4.put(i, i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("扩容一次5：" + (l2 - l));
        return (l2 - l);
    }

    private static Long demo10() {
        long l = System.currentTimeMillis();
        HashMap<Integer, Integer> map44 = new HashMap<>(16777216);
        for (int i = 1; i <= 10000000; i++) {
            map44.put(i, i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("扩容一次6：" + (l2 - l));
        return (l2 - l);
    }


    private static Long demo11() {
        long l = System.currentTimeMillis();
        HashMap<Integer, Integer> map6 = new HashMap<>(10000000);
        for (int i = 1; i <= 10000000; i++) {
            map6.put(i, i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("理论合理参数1：" + (l2 - l));
        return (l2 - l);
    }

    private static Long demo12() {
        long l = System.currentTimeMillis();
        HashMap<Integer, Integer> map = new HashMap<>(16777216);
        for (int i = 1; i <= 10000000; i++) {
            map.put(i, i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("理论合理参数2：" + (l2 - l));
        return (l2 - l);
    }


}

HashMap的扩容机制---resize()：https://www.cnblogs.com/williamjie/p/9358291.html