Android-SparseArray

SparseArray 是Android里面加入的数据结构,在插入的时候会对Key做hash，然后按照二分查找的算法去找到合适的位置插入或者更新对应的value值。和Hashmap相比较的话，用到的内存会比散列表小，因为少了那部分阈值的空数组位，但是数据量大起来后，二分查找比起散列表直接hash取位置还是要慢一些

//内部维护一个int[]类型的key数组，一个object[]类型的value数组，key会保持有序并且无重复
public class SparseArray<E> implements Cloneable {
    private static final Object DELETED = new Object();  //用于删除的标记
    private boolean mGarbage = false;
 
    private int[] mKeys;
    private Object[] mValues;
    private int mSize;
 
    public SparseArray() {
        this(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;
    }
 
    @Override
    public SparseArray<E> clone() {
        SparseArray<E> clone = null;
        try {
            clone = (SparseArray<E>) super.clone();
            clone.mKeys = mKeys.clone();
            clone.mValues = mValues.clone();
        } catch (CloneNotSupportedException cnse) {
            /* ignore */
        }
        return clone;
    }
 
    public E get(int key) {
        return get(key, null);
    }

    public E get(int key, E valueIfKeyNotFound) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
 
        if (i < 0 || mValues[i] == DELETED) {
            return valueIfKeyNotFound;
        } else {
            return (E) mValues[i];
        }
    }
 
    public void delete(int key) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
 
        if (i >= 0) {
            if (mValues[i] != DELETED) {
                mValues[i] = DELETED;
                mGarbage = true;
            }
        }
    }
 
    public void remove(int key) {
        delete(key);
    }
 
    public void removeAt(int index) {
        if (mValues[index] != DELETED) {
            mValues[index] = DELETED;
            mGarbage = true;
        }
    }
 
    public void removeAtRange(int index, int size) {
        final int end = Math.min(mSize, index + size);
        for (int i = index; i < end; i++) {
            removeAt(i);
        }
    }
 
//把数组标记为DELETED的元素置为null，非标记的元素向前移动，然后更新属性
    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;
     }
 
//首先会查找，如果找到了相同的key，会直接替换value的值，因此不会存在相同的key的情况，没找到的情况下，如果i<size并且最后一次二分查找的低位标记为DELETED的话，直接把key,value赋值过去，否则gc()一次，然后调用工具类把key,value插入到i位置，这样的话key依然是有序的
    public void put(int 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);
            }
 
            mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);
            mValues = GrowingArrayUtils.insert(mValues, mSize, i, value);
            mSize++;
        }
    }
 
    public int size() {
        if (mGarbage) {
            gc();
        }
 
        return mSize;
    }
 
    public int keyAt(int index) {
        if (mGarbage) {
            gc();
        }
 
        return mKeys[index];
    }
 
    public E valueAt(int index) {
        if (mGarbage) {
            gc();
        }
 
        return (E) mValues[index];
    }
 
    public void setValueAt(int index, E value) {
        if (mGarbage) {
            gc();
        }
 
        mValues[index] = value;
    }
 
    public int indexOfKey(int key) {
        if (mGarbage) {
            gc();
        }
 
        return ContainerHelpers.binarySearch(mKeys, mSize, key);
    }
 
    public int indexOfValue(E value) {
        if (mGarbage) {
            gc();
        }
 
        for (int i = 0; i < mSize; i++)
            if (mValues[i] == value)
                return i;
 
        return -1;
    }
 
    public void clear() {
        int n = mSize;
        Object[] values = mValues;
 
        for (int i = 0; i < n; i++) {
            values[i] = null;
        }
 
        mSize = 0;
        mGarbage = false;
    }
 
    public void append(int key, E value) {
        if (mSize != 0 && key <= mKeys[mSize - 1]) {
            put(key, value);
            return;
        }
 
        if (mGarbage && mSize >= mKeys.length) {
            gc();
        }
 
        mKeys = GrowingArrayUtils.append(mKeys, mSize, key);
        mValues = GrowingArrayUtils.append(mValues, mSize, value);
        mSize++;
    }
 
    @Override
    public String toString() {
        if (size() <= 0) {
            return "{}";
        }
 
        StringBuilder buffer = new StringBuilder(mSize * 28);
        buffer.append('{');
        for (int i=0; i<mSize; i++) {
            if (i > 0) {
                buffer.append(", ");
            }
            int key = keyAt(i);
            buffer.append(key);
            buffer.append('=');
            Object value = valueAt(i);
            if (value != this) {
                buffer.append(value);
            } else {
                buffer.append("(this Map)");
            }
        }
        buffer.append('}');
        return buffer.toString();
    }



----------------------------------------------------------------------
//上面用到的工具类的二分查找算法
    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   取反为负数，再取反可以获取二分的最后一次位置，直接插入新的值
    }