SparseArray源码分析

SparseArray源码分析

标签（空格分隔）： 未分类

---

当里个当，SparseArray 大家都说他的效率比HashMap高，但是具体为什么高，我只是听别人说高，但是里面到底是怎么算的，还是一脸的懵逼，如果别人问到，同时可用HashMap，SparseArray的情况下，为毛SparseArray效率高，如果不看源码，尼玛绝对又是大写的懵逼，为了减少懵逼状态，还是硬着头皮看看源码吧。

---

那就从最简单的看起呗：

    //用来标记values数组中被删除的位置
    private static final Object DELETED = new Object();
    //标记是否有过删除操作
    private boolean mGarbage = false;
    //key数组
    private int[] mKeys;
    //value数组
    private Object[] mValues;
    //mSize表示有效的key-value对的数目；
    private int mSize;

    /**
     * Creates a new SparseArray containing no mappings.
     */
    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;
    }

上面两个构造方法说到：如果initialCapacity=0那么mKeys,mValuse都初始化为size=0的数组，当initialCapacity>0时，系统生成length=initialCapacity的value数组，同时新建一个同样长度的key数组，EmptyArray,ArrayUtils相关源码如下：

public final class EmptyArray {
    public static final int[] INT = new int[0];
    public static final Object[] OBJECT = new Object[0];
}

public class ArrayUtils {
    private static final int CACHE_SIZE = 73;
    private static Object[] sCache = new Object[CACHE_SIZE];

     public static Object[] newUnpaddedObjectArray(int minLen) {
        return (Object[])VMRuntime.getRuntime().newUnpaddedArray(Object.class, minLen);
    }
}

继续往下看：

public E get(int key) {
    return get(key, null);
}

@SuppressWarnings("unchecked")
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];
    }
}

代码理解很简单，i肯定就是key对应的value在values数组中的下标，找到就返回mvaluses[i]，找不到就返回valueIfKeyNotFound
核心就在binarySearch(mKeys, mSize, key)这个方法了，不妨追踪进去看一下，这里面是什么算法：

class ContainerHelpers {

    // This is Arrays.binarySearch(), but doesn't do any argument validation.
    static int binarySearch(int[] array, int size, int value) {
    //除了没做参数校验，其余的和Arrays.binarySearch()一样
        int low = 0;
        int hight = size - 1;

        while (low <= hight) {
            //无符号右移运算，相当于除以2，左边补0
            final int mid = (low + hight) >>> 1;
            final int midVal = array[mid];

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

这尼玛不就是二分查找算法嘛，你看，low是第一个下标，hight是最后一个下标，如果low<=hight时，折半，找到中间下标 mid = (low+hight)>>>1，中间值即midValue = array[mid];
如果目标值value>midValue,就把low定位到mid前面一个值low = mid+1;
如果目标值value < midValue,就把high 定位到mid后一个值，hight = mid-1;
如果目标值value = midValue,直接返回。
如果都找不到，返回~low(相当于-(low+1)),这里是不是有点懵比，为毛要这样返回，直接返回一个负值不行吗？因为我们不仅想表示没找到，还想返回更多信息，即这个key如果要插进来应该在的位置（外面的代码只需要再次~即取反就可以得到这个信息

继续往下看：

  public void delete(int key) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
        if (i >= 0) {
            if (mValues[i] != DELETED) {
                mValues[i] = DELETED;
                mGarbage = true;
            }
        }
    }

这里应该也不难理解吧，i>0表示，找到了key对应的下标，否则应该是负数。同时判断mValues[i] 是不是Object这个对象，如果不是，直接替换为Object（DELETE起到标记删除位置的作用）,并标记 mGarbage=true，注意：这里delete只操作了values数组，并没有去操作key数组;

继续看下去：

//其实就是多了一步，把要删除的值返回，其余同delete一样
 public E removeReturnOld(int key) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i >= 0) {
            if (mValues[i] != DELETED) {
                final E old = (E) mValues[i];
                mValues[i] = DELETED;
                mGarbage = true;
                return old;
            }
        }
        return null;
    }

    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);
        }
    }

    //这里要留意，clear只是清空了values数组，并没有操作keys数组
    public void clear() {
    int n = mSize;
    Object[] values = mValues;

    for (int i = 0; i < n; i++) {
        values[i] = null;
    }

    mSize = 0;
    mGarbage = false;
}

上面这几个函数，基本一看就懂，没啥好说的。

下面我们一个优化的方法：

  /**
     * Puts a key/value pair into the array, optimizing for the case where
     * the key is greater than all existing keys in the array.
     */
    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++;
    }

    //工具类
    final class GrowingArrayUtils{
        //对现有数组的扩容
        public static int[] append(int[] array, int currentSize, int element) {
            assert currentSize <= array.length;

            if (currentSize + 1 > array.length) {
                int[] newArray = ArrayUtils.newUnpaddedIntArray(growSize(currentSize));
                System.arraycopy(array, 0, newArray, 0, currentSize);
                array = newArray;
            }
            array[currentSize] = element;
            return array;
    }

    }

看源码我们知道，当mSize != 0且key<=SparseArray中最大的key时，则直接调用put方法；否则当key比现存所有的key都大，这种情况下我们执行的只是put方法中i==mSize的部分（小分支，所以说是个优化相比直接调用put方法）-对比一下工具类中的两个方法就知道了。

提到了put，再来看一下put里面干了些什么见不得人的事：

 /**
     * 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(int key, E value) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i >= 0) {
            mValues[i] = value;
        } else {
        //这里就是key要插入的位置，上面二分查找方法提到过为毛这样返回，这里就用到了
            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++;
        }

    }

    //工具类
    final class GrowingArrayUtils{
         public static int[] insert(int[] array, int currentSize, int index, int element) {
            assert currentSize <= array.length;

            if (currentSize + 1 <= array.length) {
                System.arraycopy(array, index, array, index + 1, currentSize - index);
                array[index] = element;
                return array;
            }

            int[] newArray = ArrayUtils.newUnpaddedIntArray(growSize(currentSize));
            System.arraycopy(array, 0, newArray, 0, index);
            newArray[index] = element;
            System.arraycopy(array, index, newArray, index + 1, array.length - index);
            return newArray;
        }

    }

代码可以分析出，
1）当key已经存在key数组的时候，直接替换value数组中对应的值；
2）当key不存在的时候：
1. 获取key要插入的位置 i= ~i;
2. 如果i在有效范围（不需要扩容），并且此位置i被标记为删除了，直接拿来复用就好
3. 不然的话，如果mGarbage被设置了且mSize >= mKeys.length，
表示该执行gc算法了，执行之后，重新利用二分查找算法确定下key的新位置（因为index可能变了）。接下来，如果currentSize+1<=array.Length,直接就把array[index]指向element就好了；否则，扩容，生成新数组，把newArray[index]指向element,然后把array的值复制到newArray;

看的脑壳疼，终于看下来了，由于水平有限，如果有分析的模糊或者错误的地方，请各位大大指出来，以免误人子弟