再也不敢使用集合默认初始化值了

【推荐】集合初始化时，推荐使用显示指定初始化大小。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;
    //默认容量大小
    private static final int DEFAULT_CAPACITY = 10;
    /**
     * A constant holding the maximum value an {@code int} can
     * have, 2<sup>31</sup>-1.
     * 2的31次方再减1
     */
    @Native public static final int   MAX_VALUE = 0x7fffffff;
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    //空间表示方法
    transient Object[] elementData; // non-private to simplify nested class access
    //用于空实例的共享空数组实例。
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //共享空数组实例，用于默认大小的空实例。我们将其与空元素数据区分开来，
    //以了解当添加第一个元素时候何时膨胀。
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //真实大小
    private int size;
    //手工指定初始容量大小
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            //指定初始化容量大小initialCapacity大于0，
            //然后创建一个数组大小为initialCapacity
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
           //空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            //参数小于0，跑一个非法参数的异常
            throw new IllegalArgumentException("Illegal Capacity: "+                                                            initialCapacity);
        }
    }
    /**
     * Constructs an empty list with an initial capacity of ten.
     */
     //initialCapacity初始化值为10
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    //将指定的元素追加到此列表的结尾
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
     private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        //如果没有指定初始容量大小
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
           //DEFAULT_CAPACITY==10,minCapacity=1
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
     }
    //确保扩展能力
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // 溢出意识代码，
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    //扩展容量大小
    private void grow(int minCapacity) {
        // 防止扩容1.5倍之后，超过int的表示范围-----A
        int oldCapacity = elementData.length;
        //JDK1.6之前扩展50%或者50%-1，
        //下面的oldCapacity >> 1表示集合容量的二进制数向右移动一位，
        //差不多就是减半，比如oldCapacity=11,11的二进制1011，
        //1011向右移动一位变成101，则下面的计算为
        //int newCapacity=11+5
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //若果11+5=16-minCapacity<0，说明，本次扩展成功，
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //若果11+5=16>MAX_ARRAY_SIZE,
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 最好是初始化容量接近于真实使用容量大小
        //使用 Arrays.copyOf复制数组
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    //巨大容量
    private static int hugeCapacity(int minCapacity) {
        //会导致OOM
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
    //JDK1.6扩容的部分代码为下面
    public void ensureCapacity(int var1) {
        ++this.modCount;
        int var2 = this.elementData.length;
        if (var1 > var2) {
            Object[] var3 = this.elementData;
            //扩容后容量=(原来容量*3)/2+1
            //也就是是原来的1.5倍+1
            int var4 = var2 * 3 / 2 + 1;
            if (var4 < var1) {
                var4 = var1;
            }

            this.elementData = Arrays.copyOf(this.elementData, var4);
        }

    }
 }  

//默认初始化  
ArrayList arrayList=new ArrayList();
//初始化大小为1000
ArrayList arrayList=new ArrayList(1000);

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    /**
     * The default initial capacity - MUST be a power of two.
     * 初始化容量大小为16，就算是指定也必须是2的n次方
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    //最大容量MUST be a power of two <= 1<<30.
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //加载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    /**
     * The next size value at which to resize (capacity * load factor).
     * 下次扩展的阈值=容量*加载因子
     */ 
    int threshold;
    //指定初始容量大小initialCapacity，加载因子loadFactor
    public HashMap(int initialCapacity, float loadFactor) {
        //初始容量值小于0，抛出参数非法异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        //如果初始容量大于最大容量，则初始容量默认为最大容量
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
         //加载因子参数校验
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        //初始化扩容阈值
        this.threshold = tableSizeFor(initialCapacity);
    }
    /**
     * Returns a power of two size for the given target capacity.
     * 返回一个2的n次方的数
     * 如果cap=10,则返回比10大的最近的2的n次方的数，即就是16=2的4次方
     * 如果cap=8，则返回8=2的3次方
     */
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
         //如果当前集合大小比阈值大，则扩容
         if (++size > threshold) resize();
    }
    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            //真实容量大于最大容量2^30
            if (oldCap >= MAXIMUM_CAPACITY) {
                //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了  
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                //两倍的阈值    
                newThr = oldThr << 1;
        }
        else if (oldThr > 0)
            //将初始容量设置为阈值
            newCap = oldThr;
        else {
            //零初始阈值表示使用默认值
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        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;
        //.....
      }  
}

HashMap<String,Object> hashMap=new HashMap<>();
HashMap<String,Object> hashMap=new HashMap<>(1024);