SparseArray解析

SparseArray是android v4包里提供的工具类，在某些场景下可以用来替代Hashmap进行对象的存储，其内部实现了一个矩阵压缩算法，可以进行矩阵压缩，大大减少了存储空间，节约内存。此外它的查找算法是二分法，提高了查找的效率。
SparseArray的value可以是任意类型，但key只能是Integer、Long类型，所以key是Integer、Long场景下，SparseArray比Hashmap更合适。

比如：
HashMap<Integer, E> hashMap = new HashMap<Integer, E>();
替换为
SparseArray<E> sparseArray = new SparseArray<E>();

HashMap<Integer, Boolean> hashMap = new HashMap<Integer, Boolean>
替换为
SparseBooleanArray array = new SparseBooleanArray();

HashMap<Integer, Integer> hashMap = new HashMap<Integer, Integer>
替换为
SparseIntArray array = new SparseIntArray();

LongSparseArray的key为Long型

在存储数据的时候，是采用了二分法方式，以下是它采用二分法的源码：

static int binarySearch(int[] array, int size, int value) {
    int lo = 0;
    int hi = size - 1;

    while (lo <= hi) {
        final int mid = (lo + hi) >>> 1;
        final int midVal = array[mid];

        if (midVal < value) {
            lo = mid + 1;
        } else if (midVal > value) {
            hi = mid - 1;
        } else {
            return mid;  // value found
        }
    }
    return ~lo;  // value not present
}

删除的时候采用标志延迟删除:

/**
 * Removes the mapping from the specified key, if there was any.
 */
public void delete(long key) {
    int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

    if (i >= 0) {
        if (mValues[i] != DELETED) {
            mValues[i] = DELETED;
            mGarbage = true;
        }
    }
}

/**
 * Adds a mapping from the specified key to the specified value,
 * replacing the previous mapping from the specified key if there
 * was one.
 */
public void put(long key, E value) {
    int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

    if (i >= 0) {
        mValues[i] = value;
    } else {
        i = ~i;

        if (i < mSize && mValues[i] == DELETED) {
            mKeys[i] = key;
            mValues[i] = value;
            return;
        }

        if (mGarbage && mSize >= mKeys.length) {
            gc();

            // Search again because indices may have changed.
            i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
        }

        if (mSize >= mKeys.length) {
            int n = ContainerHelpers.idealLongArraySize(mSize + 1);

            long[] nkeys = new long[n];
            Object[] nvalues = new Object[n];

            // Log.e("SparseArray", "grow " + mKeys.length + " to " + n);
            System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
            System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

            mKeys = nkeys;
            mValues = nvalues;
        }

        if (mSize - i != 0) {
            // Log.e("SparseArray", "move " + (mSize - i));
            System.arraycopy(mKeys, i, mKeys, i + 1, mSize - i);
            System.arraycopy(mValues, i, mValues, i + 1, mSize - i);
        }

        mKeys[i] = key;
        mValues[i] = value;
        mSize++;
    }
}

/**
 * Returns the number of key-value mappings that this LongSparseArray
 * currently stores.
 */
public int size() {
    if (mGarbage) {
        gc();
    }

    return mSize;
}

private void gc() {
    // Log.e("SparseArray", "gc start with " + mSize);

    int n = mSize;
    int o = 0;
    long[] 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;

    // Log.e("SparseArray", "gc end with " + mSize);
}