Java中集合的扩容策略及实现的对比分析

本文将从源码角度来分析和对比一下集合扩容相关的知识，涉及到的集合框架有：ArrayList，Vector，HashMap，ArrayMap，SparseArray。下面先从ArrayList开始。

• ArrayList

  ArrayList是以数组实现的一个集合类，在ArrayList的源码中可以看到，所有元素都是被储存在elementData这个全局的数组变量中，而所谓的扩容也是针对这个数组对象进行操作。具体来说，当一个添加元素的动作，即add或addAll被执行时，都会先调用ensureCapacityInternal(…)方法进行容量预检，如果当前elementData数组的容量不足以完成本次添加操作便会进行自动扩容。该方法代码如下：

      //这是一个私有方法，ArrayList提供了另一个public的扩容方法ensureCapacity以满足外界手动扩容的需求    //其实质也是调用了本方法，在此不做累述    //minCapacity是指本次添加操作后所需要的数组容量，即elementData.length + newSize    private void ensureCapacityInternal(int minCapacity) {            //这个if判断如果成立，则代表当前ArrayList为空，而本次添加操作是第一次添加。            //此时需要将ArrayList的容量扩充至DEFAULT_CAPACITY=10和本次添加操作所要求的minCapacity二者中的较大者。            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {                minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);            }            ensureExplicitCapacity(minCapacity);    }    private void ensureExplicitCapacity(int minCapacity) {        //操作计数器+1        modCount++;        // overflow-conscious code        // 确保需要进行扩容，即当前数组的容量小于本次添加操作所要求的新的总容量        if (minCapacity - elementData.length > 0)            grow(minCapacity);    }

  在ensureCapacityInternal方法中，一开始会对本次添加操作是否为第一次添加进行判断。从源码：private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; 中可以得知，DEFAULTCAPACITY_EMPTY_ELEMENTDATA变量指代的是一个空的对象数组，这也是通过无参构造函数new出来的ArrayList对象的初始状态，也即 elementData = {}；这种情况下的第一次扩容，如果所要求的新容量小于10，则会直接扩容至10。

  下面继续看到grow方法，这个方法是ArrayList扩容操作的实现

      private void grow(int minCapacity) {        // overflow-conscious code        //记录当前elementData数组的容量        int oldCapacity = elementData.length;        //新的容量暂定为当前容量的1.5倍        int newCapacity = oldCapacity + (oldCapacity >> 1);        //如果1.5倍容量仍不满足minCapacity所要求的，则直接将容量定为minCapacity        if (newCapacity - minCapacity < 0)            newCapacity = minCapacity;        //如果新的容量超过了Integer.MAX_VALUE - 8，则做最大化处理        if (newCapacity - MAX_ARRAY_SIZE > 0)            newCapacity = hugeCapacity(minCapacity);        // minCapacity is usually close to size, so this is a win:        //将当前数组copy到新的数组中        elementData = Arrays.copyOf(elementData, newCapacity);    }    private static int hugeCapacity(int minCapacity) {        if (minCapacity < 0) // overflow            throw new OutOfMemoryError();        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;    }

  最后的扩容操作，Arrays.copyOf方法会新创建一个大小为newCapacity的数组，然后通过System.arraycopy方法将之前elementData数组中的元素复制到新数组中(起点的index为0)，并将新数组返回给变量elementData完成扩容。

• Vector

  Vector和ArrayList其实身出同门，都是AbstractList的子类并且都实现了List接口，所提供的功能也基本相同，最大的不同在于Vector所有的公有API都是加锁的，也即Vector是线程安全的。但这也正是它不受欢迎的原因之一，太重了。。。言归正传，我们来关心一下Vector的扩容操作。其实基本跟ArrayList相同，方法如下：

      private void ensureCapacityHelper(int minCapacity) {        // overflow-conscious code        //当前容量不够，扩之        if (minCapacity - elementData.length > 0)            grow(minCapacity);    }

  可以看到，基本只是方法名不一样而已，再来看看Vector的grow函数，这里还真有些不同：

      private void grow(int minCapacity) {        // overflow-conscious code        int oldCapacity = elementData.length;        //不同之处在这里，MARK        int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);        if (newCapacity - minCapacity < 0)            newCapacity = minCapacity;    if (newCapacity - MAX_ARRAY_SIZE > 0)            newCapacity = hugeCapacity(minCapacity);        elementData = Arrays.copyOf(elementData, newCapacity);    }

  上面代码块中MARK出的那一句便是不同之处，可以看出Vector的扩容是先判断有没有大于0的capacityIncrement，该变量是通过：

      public Vector(int initialCapacity, int capacityIncrement) {        super();        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);        this.elementData = new Object[initialCapacity];        this.capacityIncrement = capacityIncrement;    }

  这个带参构造函数传入的，如果不调用这个构造函数，则capacityIncrement为0。在capacityIncrement不为0的情况下，则每次扩容都暂定扩大capacityIncrement个，反之扩容oldCapacity个，即当前容量的一倍。后续的扩容操作和ArrayList一致，也是通过Arrays.copyOf方法来完成，这里不再重复分析。

• HashMap

  下面来看另一个熟人–HashMap。不同于上面两个List的实现类，HashMap是一个采用哈希表实现的键值对集合，继承自AbstractMap，实现了Map接口并使用拉链法解决Hash冲突，其内部储存的元素并不是在连续内存地址的，并且是无序的。此处我们只关心其扩容操作的逻辑和实现，先说一下，由于要重新创建数组，rehash，重新分配元素位置等，HashMap扩容的开销要比List大很多。下面介绍几个和扩容相关的成员变量：

      //哈希表中的数组，JDK 1.8之前存放各个链表的表头。1.8中由于引入了红黑树，则也有可能存的是树的根    transient Node<K,V>[] table;    //默认初始容量：16，必须是2的整数次方。这样规定是因为在通过key来确定元素在table中的index时    //所用的算法为:index = (n - 1) & hash，其中n即为table容量。保证n是2的整数次方就能保证n-1的低位均为1，    //这样便能保留hash(key)得到的hash值的所有低位，从而保证得到的index在n范围内分布均匀，因为hash算法的结果就是均匀的    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;     //默认加载因子为: 0.75，这是在时间、空间两方面均衡考虑下的结果。    //这个值过大会导致发生冲突的几率增加，容易形成长链表，降低查找效率；太小则会导致频繁的扩容，降低整体性能。    static final float DEFAULT_LOAD_FACTOR = 0.75f;    //阈值，下次需要扩容时的值，等于 容量*加载因子    int threshold;    //最大容量： 2^30次方    static final int MAXIMUM_CAPACITY = 1 << 30;    //树化阈值。JDK 1.8后HashMap对冲突处理做了优化，引入了红黑树。    //当桶中元素个数大于TREEIFY_THRESHOLD时，就需要用红黑树代替链表，以提高操作效率。此值必须大于2，并建议大于8    static final int TREEIFY_THRESHOLD = 8;    //非树化阈值。在进行扩容操作时，桶中的元素可能会减少，这很好理解，因为在JDK1.7中，    //每一个元素的位置需要通过key.hash和新的数组长度取模来重新计算，而1.8中则会直接将其分为两部分。    //并且在1.8中，对于已经是树形的桶，会做一个split操作(具体实现下面会说)，在此过程中，    //若剩下的树元素个数少于UNTREEIFY_THRESHOLD，则需要将其非树化，重新变回链表结构。    //此值应小于TREEIFY_THRESHOLD，且规定最大值为6    static final int UNTREEIFY_THRESHOLD = 6;

  好了，相关变量介绍完了，接下来开始分析HashMap的扩容函数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-else是为了确定newCap和newThr，即新的容量和扩容阈值    if (oldCap > 0) {        //oldCap不为0，已被初始化过        if (oldCap >= MAXIMUM_CAPACITY) {            //当前已经是最大容量，不允许再扩容，返回当前哈希表            threshold = Integer.MAX_VALUE;            return oldTab;        }        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                 oldCap >= DEFAULT_INITIAL_CAPACITY)            //先将oldCap翻倍，如果得到的值小于最大容量，并且oldCap不小于默认初始值，则将扩容阈值也翻倍，结束            newThr = oldThr << 1; // double threshold    }    else if (oldThr > 0)         // initial capacity was placed in threshold        // 若构造函数中有传入initialCapacity，则会暂存在oldThr=threshold变量中。        // 然后在第一次put操作导致的resize方法中被赋给newCap，这样做的目的应该是避免污染oldCap从而影响上面那个if的判断        // 从这里也可以看出HashMap对于所需内存的申请是被延迟到第一次put操作时进行的，而非在构造函数中。        newCap = oldThr;    else {                       // zero initial threshold signifies using defaults        // Map没有被初始化，用默认值初始化        newCap = DEFAULT_INITIAL_CAPACITY;        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);    }    if (newThr == 0) {        //若经过计算后，新阈值为0，则赋值为新容量和扩容因子的乘积(需考虑边界条件)        float ft = (float)newCap * loadFactor;        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?                  (int)ft : Integer.MAX_VALUE);    }    threshold = newThr;    /******-----分割线，至此新的容量和扩容因子已确定------*************/    @SuppressWarnings({"rawtypes","unchecked"})    //创建一个大小为newCap的Node<K,V>数组，并赋值给table变量        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];    table = newTab;    if (oldTab != null) {        //遍历扩容前的数组        for (int j = 0; j < oldCap; ++j) {            Node<K,V> e;            if ((e = oldTab[j]) != null) {                //将原数组中第j个元素赋给e，并将原数组第j位置置空                oldTab[j] = null;                if (e.next == null)                    //该元素没有后续节点，即该位置未发生过hash冲突。则直接将该元素的hash值与新数组的长度取模得到新位置并放入                    newTab[e.hash & (newCap - 1)] = e;                else if (e instanceof TreeNode)                    //JDK1.8中，如果该元素是一个树节点，说明该位置存放的是一颗红黑树，则需要对该树进行分解操作                    //具体实现后面会讨论，这里split的结果就是分为两棵树(这里必要时要进行非树化操作)并分别放在新数组的高段和低段                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);                else { // preserve order                    //剩下这种情况就是该位置存放的是一个链表，需要说明的是在JDK1.7和1.8中这里有着不同的实现，下面分别讨论                    /******--- JDK 1.7版本 starts ---*******/                    //遍历链表                    while(null != e) {                        //将原链表中e的下一个元素暂存到next变量中                        HashMapEntry<K,V> next = e.next;                        //算出在新数组的index=i，indexFor其实就是e.hash & (newCapacity - 1)                        int i = indexFor(e.hash, newCapacity);                        //改变e.next的指向，将新数组该位置上原先的内容(一个链表，元素或是null)挂在e的身后，使e成为这个链表的表头                        e.next = newTable[i];                        //将这个e位表头的新链表放回到index为i的位置中                        newTable[i] = e;                        //将之前暂存的原链表中的下一个元素赋给e，继续遍历原链表                        e = next;                    }                    /******--- JDK 1.7版本 ends ---*******/                    /******--- JDK 1.8版本 starts ---*******/                    //在1.8的实现中，新数组被分成了高低两个段，而原链表也会被分成两个子链表，分别放入新数组的高段和低段中                    //loHead和loTail用于生成将被放入新数组低段的子链表                    Node<K,V> loHead = null, loTail = null;                    //hiHead和hiTail则用于生成将被放入新数组高段的子链表                    Node<K,V> hiHead = null, hiTail = null;                    //跟1.7中一样，next用于暂存原链表中e的下一个元素                    Node<K,V> next;                    //开始遍历原链表                    do {                        next = e.next;                        //用if中的方法确定e是该去新数组的高段还是低段                        if ((e.hash & oldCap) == 0) {                            //将e加到将被放入低段的子链表的尾部                            if (loTail == null)                                loHead = e;                            else                                loTail.next = e;                            loTail = e;                        }                        else {                            //将e加到将被放入高段的子链表的尾部                            if (hiTail == null)                                hiHead = e;                            else                                hiTail.next = e;                            hiTail = e;                        }                    } while ((e = next) != null);                    if (loTail != null) {                        //将loHead指向的子链表放入新数组中index=j的位置                        loTail.next = null;                        newTab[j] = loHead;                    }                    if (hiTail != null) {                        ////将hiHead指向的子链表放入新数组中index=j+oldCap的位置                        hiTail.next = null;                        newTab[j + oldCap] = hiHead;                    }                    /******--- JDK 1.8版本 ends ---*******/                }            }        }    }    return newTab;}

  可以看到JDK1.8对resize方法进行了彻底的改造，引入红黑树结合之前的链表势必会提高在发生hash冲突时的操作效率(红黑树能保证在最坏情况下插入，删除，查找的时间复杂度都为O(logN))。

  此外最大的改动便是在扩容的时候对链表或树的处理，在1.7时代，链表中的每一个元素都会被重新计算在新数组中的index，具体方法仍旧是e.hash对新数组长度做取模操作；而在1.8时代，这个链表或树会被分为两部分，我们暂且称其为A和B，若元素的hash值按位与扩容前数组的长度得到的结果为0（其实就是判断hash的某一位是1还是0，由于hash值均匀分布的特性，这个分裂基本可以认为是均匀的），则将其接入A，反之接入B。最后保持A的位置不变，即在新数组中仍位于原先的index=j处，而B则去到j+oldCap处。

  其实对于这个改动带来的好处我理解的不是特别透彻，因为整个过程并没有减少计算的次数。目前看到的好处是可以避免扩容重定向过程中发生哈希冲突（因为是扩容一倍，所以一个萝卜一个坑，不会有冲突），并且不会将链表中的元素倒置（考虑极端情况，就一条链表，1.7的方法每次都会将元素插到表头）。这里还是得求教大家，欢迎讨论~

  回到resize方法，上面还留了一个尾巴，就是当桶中是树形结构时的split方法，下面就来看源码：

       /**     * Splits nodes in a tree bin into lower and upper tree bins,     * or untreeifies if now too small. Called only from resize;     * see above discussion about split bits and indices.     *     * @param map the map     * @param tab the table for recording bin heads     * @param index the index of the table being split     * @param bit the bit of hash to split on     */    final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {        TreeNode节点继承自LinkedHashMapEntry，在链表节点的基础上扩充了树节点的功能，譬如left，right，parent        TreeNode<K,V> b = this;        // Relink into lo and hi lists, preserving order        // 将树分为两部分这里的做法和链表结构时是相似的        TreeNode<K,V> loHead = null, loTail = null;        TreeNode<K,V> hiHead = null, hiTail = null;        int lc = 0, hc = 0;        //遍历整棵树，这里说明一下，由于这棵树是由链表treeify生成的，其next指针依旧存在并指向之前链表中的后继节点，        //因此遍历时依然可以按照遍历链表的方式来进行        for (TreeNode<K,V> e = b, next; e != null; e = next) {            //暂存next            next = (TreeNode<K,V>)e.next;            //将e从链表中切断            e.next = null;            //与对链表的处理相同，若e.hash按位与bit=oldCap结果为0，则接到低段组的尾部            if ((e.hash & bit) == 0) {                if ((e.prev = loTail) == null)                    loHead = e;                else                    loTail.next = e;                loTail = e;                ++lc;            }            //否则接到高段组的尾部            else {                if ((e.prev = hiTail) == null)                    hiHead = e;                else                    hiTail.next = e;                hiTail = e;                ++hc;            }        }        //若低段不为空        if (loHead != null) {            //如果低段子树的元素个数小于非树化阈值，则将该树进行非树化，还原为链表            if (lc <= UNTREEIFY_THRESHOLD)                tab[index] = loHead.untreeify(map);            else {                //否则的话将低段子树按照原本在旧数组中的index放入新数组中                tab[index] = loHead;                //对低段子树进行树化调整。这里有一个优化，如果发现高段子树为空，则说明之前树中的所有元素都被放到了低段子树中，                //也即这已经是一棵完整的，调整好了的红黑树，不需要再进行树化调整                if (hiHead != null) // (else is already treeified)                    loHead.treeify(tab);            }        }        if (hiHead != null) {            //与低段子树同样的逻辑，放入新数组的位置为旧数组的index+oldCap            if (hc <= UNTREEIFY_THRESHOLD)                tab[index + bit] = hiHead.untreeify(map);            else {                tab[index + bit] = hiHead;                //这里同样的，如果低段子树为空，说明高段这棵树已经是一棵完整的红黑树，无需调整                if (loHead != null)                    hiHead.treeify(tab);            }        }    }

  注：由于篇幅所限，红黑树的treeify树化操作和untreeify非树化操作将在另一篇关于红黑树的文章中单独进行说明，在此大家只需理解treeify做的事情是将一个链表中的TreeNode节点，按照二叉查找树的结构连接其left，right和parent指针，并根据红黑树的规则进行调整，同时也可以对一个非红黑树的树结构进行调整；而untreeify反之，是将一个红黑树的TreeNode节点还原为HashMap.Node节点，并将其首尾相连还原为一个链表结构。

  至此，HashMap的扩容逻辑和实现就分析完成了，可以看到1.7中的逻辑和做法还比较简单粗暴，而到了1.8中由于红黑树的引入，整体变得精巧了许多，整体HashMap的操作性能也有了大的提升。但即便如此，HashMap的扩容依旧是一个很贵的操作，这就要求我们在初始化HashMap的时候根据自己的业务场景设置尽可能合适的初始容量，以降低扩容发生的几率。例如我需要一个容纳96个元素的map，那么只要我把capacity初始值设置为128，那么就不会经历16到32到64再到128的三次扩容，这样来说是节省内存和运算成本的。当然如果需要容纳97个元素的话，因为超过了capacity值的3/4，所以就需要设置为256了，否则也会经历一次扩容。

• ArrayMap

  ArrayMap是一个(key,value)映射的数据结构，它设计上更多的是考虑内存的优化，内部是使用两个数组进行数据存储，一个数组记录key的hash值，另外一个数组记录Value值。它会对key使用二分法进行从小到大排序，在添加、删除、查找数据的时候都是先使用二分查找法得到相应的index，然后通过index来进行添加、查找、删除等操作。相比于HashMap，它更适合在数据量不是很大的情况下(千级)使用，有点用时间换空间的意思，如果在数据量比较大的情况下，那么它的性能将退化至少50%。

  下面还是先来看看跟ArrayMap扩容相关的成员变量：

          //最小扩容容量，即一次扩容最少扩大4个        private static final int BASE_SIZE = 4;        //第一个数组，存放所有key的hash值，这个数组的容量就是ArrayMap当前的容量        int[] mHashes;        //第二个数组，容量是mHashes的两倍，元素的key和value被相邻存放，即一个元素占两格        Object[] mArray;        //ArrayMap中当前元素的个数，也即mHashes数组中元素的个数        int mSize;        //小号缓存数组，数组长度为8，其中index=0位置存放的是指向下一个缓存数组index=0位置的指针，        //即该位置存储的其实是一个链表，链表元素为一个一个的mBaseCache数组，其通过index=0位置相连        //index=1位置存放的是一个长度为4的数组，供mHashes使用        static Object[] mBaseCache;        //小号缓存数组中index=0的位置存放的链表的长度        static int mBaseCacheSize;        //大号缓存数组，数组长度为16，其中index=0位置存放的是指向下一个缓存数组index=0位置的指针，        //即该位置存储的其实是一个链表，链表元素为一个一个的mTwiceBaseCache数组，其通过index=0位置相连        //index=1位置存放的是一个长度为8的数组，供mHashes使用        static Object[] mTwiceBaseCache;        //大号缓存数组中index=0的位置存放的链表的长度        static int mTwiceBaseCacheSize;        //缓存数组中的链表的最大长度，不能超过10        private static final int CACHE_SIZE = 10;

  相关成员变量就是这些，先提一句，ArrayMap不同于HashMap，如果你在构造函数中指定了capacity，则构造函数会直接为mHashes和mArray两个数组申请内存，并不会延迟到第一次put。如果不指定capacity，则两个数组会被分别赋值为EmptyArray.INT和EmptyArray.OBJECT，即对于类型的空数组。下面我们来看扩容的实现：

         /**        * Ensure the array map can hold at least <var>minimumCapacity</var>        * items.        */        //这个方法在putAll中会被调用，传入的参数是mSize+array.size()，即当前个数与新put进来的集合个数的和。        //这个方法并没有在put中被调用，但核心方法都是allocArrays(capacity)，唯一的差别在于这个capacity的计算方法，        //所以此处我们先用它来分析，至于计算capacity的区别后面会提到。        //minimumCapacity这个输入参数表示新的操作需要这个容量来支撑，也即新的最小容量        public void ensureCapacity(int minimumCapacity) {            //暂存扩容前的元素个数至osize            final int osize = mSize;            //若当前ArrayMap的容量小于所需的最小容量，则进行扩容            if (mHashes.length < minimumCapacity) {                //暂存扩容前的mHashes数组至ohashes                final int[] ohashes = mHashes;                //暂存扩容前的mArray数组至oarray                final Object[] oarray = mArray;                //申请内存，核心操作，后面单独分析                allocArrays(minimumCapacity);                //若ArrayMap中有元素                if (mSize > 0) {                    //这里的mHashes是经过扩容后的空数组，这一句是将扩容前暂存的ohashes中的内容copy到新的mHashes中                    System.arraycopy(ohashes, 0, mHashes, 0, osize);                    //同理，这里的mArray是经过扩容后的空数组，这里将扩容前暂存的oarray中的内容copy到新的mArray中                    System.arraycopy(oarray, 0, mArray, 0, osize<<1);                }                //善后工作，该缓存的缓存，该置空的置空                freeArrays(ohashes, oarray, osize);            }            if (CONCURRENT_MODIFICATION_EXCEPTIONS && mSize != osize) {                throw new ConcurrentModificationException();            }        }

  下面继续看真正干活儿的allocArrays方法，上面说到的putAll方法会通过ensureCapacity来调用到这个方法，传入的size为mSize+array.size()。除此之外，构造函数中根据指定的capacity初始化数组的操作也是通过这个函数完成的，size自然就是指定的capacity。但是最常用到的还是put方法，即添加单个元素，put中调用allocArrays(size)时传入的size是这样算出来的：

      final int n = osize >= (BASE_SIZE*2) ? (osize+(osize>>1))                : (osize >= BASE_SIZE ? (BASE_SIZE*2) : BASE_SIZE);

  翻译一下就是先判断mSize值是否大于等于8，如果是则n=mSize*1.5，如果否，则判断是否大于等于4，是则n=8个，否则n=4个。

      private void allocArrays(final int size) {        if (mHashes == EMPTY_IMMUTABLE_INTS) {            throw new UnsupportedOperationException("ArrayMap is immutable");        }        if (size == (BASE_SIZE*2)) {            //线程安全，并且上的是类锁            synchronized (ArrayMap.class) {                //若要求的size是8，且大号缓存数组不为空，则从大号缓存数组中取缓存                if (mTwiceBaseCache != null) {                    //将当前大号缓存数组赋给array，其容量为16，符合mArray的要求                    final Object[] array = mTwiceBaseCache;                    mArray = array;                    //index=0的位置存放的是指向下一个大号缓存数组的指针，取出赋给mTwiceBaseCache变量，即第一层缓存被mArray取走了                    mTwiceBaseCache = (Object[])array[0];                    //第一层缓存的index=1的位置存放的是长度为8的数组，赋给mHashes                    mHashes = (int[])array[1];                    //将已经取出的第一层缓存数组的前两位都清空，这样一来便得到了长度分别为16和8的空的mArray和mHashes数组，好精巧的设计！                    array[0] = array[1] = null;                    //大号缓存被取走了一层，链表长度减一                    mTwiceBaseCacheSize--;                    if (DEBUG) Log.d(TAG, "Retrieving 2x cache " + mHashes                            + " now have " + mTwiceBaseCacheSize + " entries");                    return;                }            }        } else if (size == BASE_SIZE) {            //这边size=4，与上同理，只是操作的缓存对象变成了小号缓存数组            synchronized (ArrayMap.class) {                if (mBaseCache != null) {                    final Object[] array = mBaseCache;                    mArray = array;                    mBaseCache = (Object[])array[0];                    mHashes = (int[])array[1];                    array[0] = array[1] = null;                    mBaseCacheSize--;                    if (DEBUG) Log.d(TAG, "Retrieving 1x cache " + mHashes                            + " now have " + mBaseCacheSize + " entries");                    return;                }            }        }        //如果要求的size不是4或8，则不满足使用缓存的条件，直接按照要求的size新创建两个数组        mHashes = new int[size];        mArray = new Object[size<<1];    }

  上面缓存的逻辑有点绕，还有一个缓存相关的地方需要分析一下，就是freeArrays这个方法，不要被它的名字迷惑了，它不光是做了回收内存，上面两个缓存数组的添加就是在这里完成的，下面来看一下：

      //调用时是这个样子的，三个参数分别为扩容前暂存的mHashes,mArrays和mSize    freeArrays(ohashes, oarray, osize);    private static void freeArrays(final int[] hashes, final Object[] array, final int size) {        if (hashes.length == (BASE_SIZE*2)) {            synchronized (ArrayMap.class) {                //若需要回收的容量为8，并且大号缓存数组的链表长度还没到10                if (mTwiceBaseCacheSize < CACHE_SIZE) {                    //直接将传入的array数组（显然，此处长度为16）作为新一层的缓存，index=0的位置指向现有的缓存数组                    array[0] = mTwiceBaseCache;                    //index=1的位置指向本次传入的hashes数组，也即将这个hashes缓存在此                    array[1] = hashes;                    //将后面14个位置都置空，因为已经无用，避免内存泄漏                    for (int i=(size<<1)-1; i>=2; i--) {                        array[i] = null; //for gc                    }                    //将这层新做好的缓存数组赋值给mTwiceBaseCache变量，下次allocArray中就能通过mTwiceBaseCache变量取到这一层缓存。这里缓存层也是后进先出，类似于栈。                    mTwiceBaseCache = array;                    //大号缓存数组的链表长度加1                    mTwiceBaseCacheSize++;                    if (DEBUG) Log.d(TAG, "Storing 2x cache " + array                        + " now have " + mTwiceBaseCacheSize + " entries");                }            }        } else if (hashes.length == BASE_SIZE) {            synchronized (ArrayMap.class) {                //这边size=4，与上同理，只是操作的缓存对象变成了小号缓存数组                if (mBaseCacheSize < CACHE_SIZE) {                    array[0] = mBaseCache;                    array[1] = hashes;                    for (int i=(size<<1)-1; i>=2; i--) {                        array[i] = null;                    }                    mBaseCache = array;                    mBaseCacheSize++;                    if (DEBUG) Log.d(TAG, "Storing 1x cache " + array                        + " now have " + mBaseCacheSize + " entries");                }            }        }    }

  到这里ArrayMap的扩容机制就分析完毕了，可以看到ArrayMap内部对于内存的使用进行很大的优化，不仅将每次扩容的容量通过4和8分为三个档位，更是对于4和8的数组采取了缓存的机制，以避免重复创建对象。尤其是缓存结构的设计不可谓不精妙，看完之后只能感叹路还很长，自己何时能设计出如此精妙的结构！

  言归正传，其实ArrayMap是在Android SDK中存在，专门供Android使用以在数据量不大的场景下替换HashMap的。通过上面对两者扩容机制的分析不难看出其在这方面的区别：HashMap每次扩容是直接申请双倍于当前容量的内存，而ArrayMap则是根据所需size大小，如果size长度大于8时申请size*1.5个长度，大于4小于8时申请8个，小于4时申请4个。这样一来同等情况下，粒度更细的ArrayMap自然会申请更少的内存空间，同时导致的问题就是扩容频率会大于HashMap。另外由于ArrayMap在查找元素使用的是二分法，当数据量过大时性能会远不如用hash值定位的HashMap。但众所周知内存对于移动设备来说有多么珍贵，因此ArrayMap这种用时间换空间的做法，在数据量较小的时候是非常适合于Android应用的。

• SparseArray

  最后再来看一下SparseArray，与ArrayMap类似，这也是Android对于HashMap的一种优化和替代方案，不同的是它只能将int作为key的类型（注意是int不是Integer），也就是说它不会对key进行自动装箱，这个是当key为int时SparseArray优于ArrayMap的地方，所以对于数据量不大，且确定key为int类型的场景，可以使用SparseArray代替HashMap或ArrayMap，因为它避免了自动装箱的过程。

  SparseArray内部也是通过两个数组来存储数据，一个存key，一个存value。由于key只能是int，所以比较时只需要看是否相等即可，所以结构非常简单。它的扩容是通过GrowingArrayUtils.growSize(int currentsize)方法来完成的，这个工具类位于android.support.v7.content.res包中，其中输入参数是指扩容前当前的数组容量，这个方法非常简单：

      public static int growSize(int currentSize) {        //当前容量不大于4，就扩容到8，否则就扩容一倍        return currentSize <= 4 ? 8 : currentSize * 2;    }

• 最后

  至此几个常用的集合类的扩容机制就都分析完毕了，下面给出一个简单的表格用于总结：

  容器 单次扩容容量 缓存策略 ArrayList 默认扩容当前容量的一半，若不满足需求，则扩容至需求容量（此处需考虑边界情况，若所需求容量超过了Integer.MAX_VALUE - 8，则做最大化处理） 无 Vector 可在构造函数中指定，默认扩容一倍 无 HashMap 扩容一倍，并进行rehash 无 ArrayMap 所需size长度大于8时申请size*1.5个长度，大于4小于8时申请8个，小于4时申请4个 对长度为4和8的数组进行缓存 SparseArray 当前容量不大于4，就扩容到8，否则就扩容一倍 无

  后续会继续对这些集合类的查找，添加，删除操作，线程安全性以及HashMap中的红黑树等方面做源码分析，感谢阅读！

• 感谢

  http://blog.csdn.net/u011240877/article/details/53351188

  http://blog.csdn.net/u011240877/article/details/53358305

  http://blog.csdn.net/vansbelove/article/details/52422087

版权声明：原创不易，转载前请留言获得作者许可，转载后标明作者 Troy.Tang 与 原文链接。