SparseArray源码分析

存储结构	默认大小	线程安全	扩容机制	删除策略	适用场景
数组	10	否	size * 2	延迟删除、仅收缩元素不收缩内存	数据小于1000，key为int类型

创建集合对象

    private boolean mGarbage = false;
    private int[] mKeys;
    private Object[] mValues;
    private int mSize;

   public SparseArray() {
        this(10);//默认大小为10
    }
    
   public SparseArray(int initialCapacity) {
        if (initialCapacity == 0) {
            mKeys = EmptyArray.INT;
            mValues = EmptyArray.OBJECT;
        } else {
            mValues = ArrayUtils.newUnpaddedObjectArray(initialCapacity);
            mKeys = new int[mValues.length];
        }
        mSize = 0;
    }

上述代码是SparseArray创建的过程，其中细节如下：

1. 默认值为10，可以传递任意值作为容量
2. mKeys类型为int[]， mValues类型为Object[]。且mKeys和mValues长度相等。

插入操作

public void put(int key, E value) {
        //二分查找法去查找当前key对应在mKeys中的下标，通过该操作可以发现SparseArray中的数据是按照key值递增存储的
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

       //如果在mKeys中找到当前key，则i必大于等于0，若没有找到则返回其应该插入位置的index的取反值
        if (i >= 0) {
            mValues[i] = value;
        } else {
            i = ~i;//再次取反，找到应该插入的位置
            //如果之前该位置已删除存储的value，则复用并返回
            if (i < mSize && mValues[i] == DELETED) {
                mKeys[i] = key;
                mValues[i] = value;
                return;
            }
            //如果当前存储的数据量大于mKeys的长度，并且需要回收标记删除的对象
            //这里mGarbage在删除元素时会被设置为true，这里的mSize其实并不仅包含有效值，还包含被标记删除的值，mSize >= mKeys.length这个条件成立的场景是数组满了
            if (mGarbage && mSize >= mKeys.length) {
                //该方法回收mValues中标记删除的对象，并设置新的size
                gc();

                //因为gc方法会导致mKeys和mValues长度和内容的变化，所以这里再一次却确认下当前key再mKeys的下标
                i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
            }
            mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);
            mValues = GrowingArrayUtils.insert(mValues, mSize, i, value);
            mSize++;
        }
    }
    
    private void gc() {
        int n = mSize;
        int o = 0;
        int[] keys = mKeys;
        Object[] values = mValues;
        for (int i = 0; i < n; i++) {
            Object val = values[i];
            if (val != DELETED) {
                if (i != o) {
                    keys[o] = keys[i];
                    values[o] = val;
                    values[i] = null;
                }
                o++;
            }
        }

        mGarbage = false;
        mSize = o;
    }

GrowingArrayUtils.java

    public static int[] insert(int[] array, int currentSize, int index, int element) {
        assert currentSize <= array.length;
       //如果当前array还有剩余空间，则直接采用System.arraycopy
        if (currentSize + 1 <= array.length) {
            System.arraycopy(array, index, array, index + 1, currentSize - index);
            array[index] = element;
            return array;
        }
        //新建容量为currentSize两倍的数组
        int[] newArray = new int[growSize(currentSize)];
        System.arraycopy(array, 0, newArray, 0, index);//拷贝原数据index之前到数据到新数组
        newArray[index] = element;//插入新值
        System.arraycopy(array, index, newArray, index + 1, array.length - index);
        return newArray;//返回新建数组，该操作会覆盖原数组引用
    }

   //数组扩容机制：2倍size成长
   public static int growSize(int currentSize) {
        return currentSize <= 4 ? 8 : currentSize * 2;
    }

由put方法可以了解到：

1. SparseArray存储的数据的key值递增存储在mKeys数组中，查找采用二分查找
2. 扩容倍数为原数组的二倍
3. 采用System.arraycopy方法拷贝内容
4. put方法中的gc方法只在原数组上进行元素收缩，数组的长度不会改变，所以不会触发内存收缩

删除

    public void delete(int key) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i >= 0) {
            //如果找到该key对应的value，并且该value没有标记删除，则标记删除并设置mGarbage = true，表明后续可以进行垃圾回收
            if (mValues[i] != DELETED) {
                mValues[i] = DELETED;
                mGarbage = true;
            }
        }
    }

1. delete方法只是标记删除，没有真正收缩数组中的元素