Android SparseArray★★

1.SparseArray（稀疏数组）

SparseArray是Android中特有的数据结构，标准的jdk里是没有这个类的。在Android内部用来替代HashMap<Integer,E>这种形式。使用SparseArray更加节省内存空间的使用。SparseArray提供了类似于Map的功能，但是实现方法却和HashMap不一样。SparseArray采用两个一维数组，一个存储key(int类型)，一个存储value。而HashMap采用的是一维数组+单链表结构。

SparseArray占用内存空闲小，没有额外的Entry对象。一般几百以内的数据性能相对HashMap要好，大概提升0—50%的性能。

他的几个重要的特点：

①以键值对形式进行存储，基于二分查找，因此查找的时间复杂度为0(LogN);

②SparseArray中直接以int作为Key，避免了HashMap的装箱拆箱操作，性能更高，且int的存储开销远远小于Integer;（不支持任意类型的key，key只能是int类型）

③key总是有序的，不管经过多少次插入，key数组中key总是从小到大排列;（key不一定是连续的）

④采用了延迟删除的机制(针对数组的删除扩容开销大的问题的优化) ;

SparseArray适用于数据量不是很大，同时Key又是数字类型的场景。比如，存储某月中每天的某种数据，最多也只有31个，同时它的key也是数字（可以使用1-31，也可以使用时间戳）。再比如，你想要存储userid与用户数据的映射，就可以使用这个来存储。

 

2.SparseArray重要属性

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;

    ……

}

SparseArray中的元素较少，下面具体介绍：

①DELETED ：static final 的一个静态Object实例，当一个键值对被remove后，会在对应key的value下放置该对象，标记该元素已经被删除（延迟删除）

②mGarbage ：当值为true时，标志数据结构中有元素被删除，可以触发gc对无效数据进行回收（此时才真正删除）

③mKeys数组： 用于存放Key的数组，通过int[] 进行存储，与HashMap相比减少了装箱拆箱的操作，同时一个int只占4字节。一个重要特点，mKeys的元素是升序排列的，也是基于此，才能使用二分查找

④mValues数组：用于存放与Key对应的Value，通过数组的position 进行映射；如果存放的是int型等，可以用SparseIntArray ，存放的Values也是int数组，性能更高

⑤mSize：mSize的大小等于数组中mValues的值为非DELETED的元素个数

mKeys和mValues读写时采用的下标是一一对应的。

下面通过一个例子体会一下mSize和mKeys、mValues的对应关系：

SparseArray<Object> SparseArray = new SparseArray<>();

sparseArray.put(0,null);

sparseArray.put(1,"android");

sparseArray.put(3,1);

sparseArray.put(35,new Boolean(true));

sparseArray.put(2,new String("java"));

sparseArray.put(18,new Object());

sparseArray.put(0,"hello world");

int size = sparseArray.size();

for(int i = 0; i <size;i++) {

   log.d(TAG,"i = " + i+ "  ;value = " + SparseArray.get(sparseArray.keyAt(i)));

}

例子中new了一个SparseArray，注意声明时只能指定value的类型，而key是固定为int的。然后再往里面添加key和value。注意key为0的情况插入了两次。

然后通过debug可以看到在内存中SparseArray是如何存储的，如下图可以看出key和value的大小都是11，而且keys的值是按从小到大排序的：

mGarbage=false

mSize=6

   mKeys:{int[11]}              mValues:{Object[11]}

             0=0                               0="hello world"

             1=1                                1="android"  

             2=2                                2="java"

             3=3                                3={Integer} 1

             4=18                              4={Object}

             5=35                              5={Boolean}true

             6=0

             7=0

             8=0

             9=0

             10=0

此时sparseArray.size()结果为6，mSize也为6。

虽然内存中为mKeys和mValues开辟了11个空间，但是你无法取得index>=6的数据，会报越界错误。

当执行sparseArray.delete(18);删除key=18的数据后，mSize、mKeys、mValues变化如下：

mGarbage=true

mSize=5

   mKeys:{int[11]}              mValues:{Object[11]}

             0=0                               0="hello world"

             1=1                                1="android"  

             2=2                                2="java"

             3=3                                3={Integer} 1

             4=18                             4=DELETED

             5=35                             5={Boolean}true

             6=0

             7=0

             8=0

             9=0

             10=0

此时sparseArray.size()结果仍然为6，mSize已经变成5。

注意：mValues只显示了非空数据。

3.构造方法

/* 

 *Creates a new SparseArray containing no mappings

*/

public SparseArray() {

    this(10);

}

public SparseArray(int initialCapacity) {

    if(initialCapacity == 0) {

        mKeys = Empty array.INT;

        mValues = Empty array.OBJECT;

    } else {

        mValues = ArrayUtils.newUnpaddedObjectArray(initialCapacity);

        mKeys = new int[mValues.length];

    }

    mSize = 0;

}

可以看出，SparseArray的默认容量是10。（HashMap默认容量为16）

SparseArray并不像HashMap一样定义了最大容量是多少，它最大可以达到Integer.MAX_VALUE，可能会报OOM。每次扩容时，如果当前容量小于5则扩容为8，否则扩容为原容量的2倍。

4.删除方法

SparseArray使用的是标记删除的方法，即直接将目标位置的有效元素设置为DELETED标记对象。

public void delete(int key) {

    //查找对应key在数组中的下标，如果存在，返回下标；不存在，返回下标的取反

    int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

    //key存在于mKeys数组中，将元素删除，用DELETED替换原value，起标记作用

    if (i >= 0) {

        if (mValues[i] != DELETED) {

            mValues[i] = DELETED;

            mGarbage = true;

        }

    }

}

//删除指定key对应的键值对，并返回旧值

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;

}

//删除指定key对应的键值对

public void remove(int key) {

    delete(key);

}

首先通过ContainerHelpers.binarySearch来进行二分查找，找到对应的key，返回的 i 就是对应数组的下标。

下面看看该方法的实现原理：

class ContainerHelpers {

    //第一个参数array为keys的数组，第二个为数组中元素个数（与keys的length不一定相等），第三个value为目标的key

    static int binarySearch(int[] array, int size, int value) {     

        int lo = 0;//当前下标，lo为二分查找的左边界

        int hi = size - 1;//数组下标值的最大值。hi为二分查找的右边界   

        while (lo <= hi) {  //还没找到，继续查找

            //左边界+右边界除以2，获取到mid 的index

            final int mid = (lo + hi) >>> 1;

            //获取中间元素

            final int midVal = array[mid];

            if (midVal < value) {  // 目标key在右部分 ，即数组中间处的值比要找的值小，代表要找的值在数组的中后部分，所以当前下标取值为mid+1

                lo = mid + 1;

            } else if (midVal > value) {  // 目标key在左部分 ，即数组中间处的值比要找的值大，代表要找的值在数组的前中部分，所以当前下标取值为mid-1

                hi = mid - 1;

            } else {

                //中间处的值与要找的值相等，直接返回key对应在array的下标

                return mid; 

            }

        }

        //上述没找到匹配值的时候，lo最终变成了要添加元素的位置，此处取反会变成负数，负数表示没有找到，对这个负数再取反代表的就是要添加元素的位置。对lo取反！！！很重要

        return ~lo; // value not present

    }

这部分代码很简单，重点就在于最后的return，可能往往二分查找没有找到都是返回-1，但是这里返回了~lo，取反导致下标小于0，用于判断没有找到。这个主要用在put方法中，稍后再讲。现在只要知道，该方法是通过二分查找返回了当前key对应于mKeys数组的下标，如果没有找到，就返回一个特殊的负数。

现在得到了下标i，如果非负数，就对其所对应的value进行替换成DELETED，用于标记该key已经被删除，同时，将garbage赋值true，代表数组中可能存在垃圾。

总结：remove方法主要做的就是这些，找到需要删除的key，并将对应的value用DELETED替换；但是key仍然存在于mKeys数组，因此删除是一个伪删除。这就是所谓的延迟删除机制。

接下来，去put方法中切身体会一下延迟删除的作用和好处。

 

5.put方法

public void put(int key, E value) {

    int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

    if (i >= 0) { //要put的key已经存在，可能是remove后，value存放着DELETED，也可能是存放旧值，那么就直接替换value值

        mValues[i] = value;

    } else { // 要put的key不存在，则对i取反，因为i已经取过一次反，这里再次取反，则得到要put的key的在mKeys中的正确下标

        i = ~i;

        //如果 i 小于数组长度，且mValues==DELETED(i对应的Key被延迟删除了)

        if (i < mSize && mValues[i] == DELETED) {

            //直接取代，实现真实删除原键值对

            mKeys[i] = key;

            mValues[i] = value;

            return;

        }

        //数组中可能存在延迟删除元素且当前数组长度满，无法添加

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

             //真实删除，将所有延迟删除的元素从数组中清除

            gc();

            //清除后重新确定当前key在数组中的目标位置

            i = ~ContainerHelpers.binarySearch( mKeys, mSize, key);

        }

        //不存在垃圾或者当前数组仍然可以继续添加元素，不需要扩容，则将 i 之后的元素全部后移，数组中仍然存在被DELETED的垃圾key

        mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);

        mValues = GrowingArrayUtils.insert( mValues, mSize, i, value);

        //新元素添加成功，潜在可用元素数量+1

        mSize++;

    }

}

通过put源码，可以总结如下：

①通过二分法找出key的下标，判断是否已经存在要添加的key，如果找到直接替换对应的value

②如果不存在要添加的key，且容量充足，则直接添加

③如果不存在要添加的key，则分别对key和value的两个数组进行扩容并添加元素

透过put的操作可以得到的信息有：

①SparseArray是允许插入value为null的情况，因为key为int类型，所以不存在key为null的情况

②SparseArray添加元素时key是确保有序的，是按key的大小进行排序的，因此它采用的二分法先找到对应key对应的下标

③SparseArray默认每次扩容是原容量的2倍（特殊情况：如果当前容量小于5则扩容为8）

可以看到，put方法也调用了ContainerHelpers.binarySearch方法先进行查找，查找到大于0，则在数组中找到了对应的key，此时，直接将value进行替换即可。如果没有找到，返回的是~lo，那么，将i赋值~~lo,即i=lo，此时i就是需要插入的位置。

用个例子展示一下，如果我们查找Key=2：

 此时，lo大于hi，退出循环，lo对应的下标为2，且是插入Key=2的理想位置；因此，这个lo取反，有两个重要的作用：

①代表没有找到对应的key

②对返回值重新取反后，得到的就是lo，就是应该插入的元素。此时将key下标为lo及之后的元素后移，再将当前元素插入该位置，就完成了一次有序插入。

此刻，找到了i，就是目标位置，如果没有设置延迟删除（DELETED）。那么由于数组的特点，我们需要将 i 序号之后的数组后移，这样就会产生一个较大的性能损耗。但是如果设置了延迟删除且mValue[i]上当前的元素恰巧为DELETED，那么此时我们可以用当前的key替换原来mKeys的key，且用当前value替换DELETED，这样就成功避免了一次数组的迁移操作。

但是事情不可能永远凑巧，如果i上的元素并非恰好被删除呢？那么此时会判断mGarbage，如果为true就执行一次gc(gc的作用就是，如果有DELETED对象存在，就重新整理一下数组，将DELETED对象都移除，数组中只保留有效数据即可)，将无效数据移除，再进行一次二分查找，然后将 i 之后的数据全部后移，将当前key插入；如果mGarbage为false，那么证明其中的数据全部存在，因此不需要gc，直接进行元素插入并将数组后移。

其中GrowingArrayUtils.insert主要做的就是调用System.arraycopy将数组后移，如果需要扩容则扩容。

public static int[] insert(int[] array, int currentSize, int index, int element) {

    assert currentSize <= array.length;

    if (currentSize + 1 <= array.length) {

        //如果当前数组容量充足，先将当前下标index往后移

        System.arraycopy(array, index, array, index + 1, currentSize - index);

        //再将要添加的元素放到下标为index的地方

        array[index] = element;

        return array;

    }

    //如果容量不足，先进行扩容，生成新的数组

    int[] newArray = ArrayUtils.newUnpaddedIntA rray(growSize(currentSize));

    //将原数组中index个元素拷贝到新数组中

    System.arraycopy(array, 0, newArray, 0, index);

   //将要添加的元素添加到index位置

     newArray[index] = element;

    //将原数组中index+1之后的元素拷贝到新数组中

    System.arraycopy(array, index, newArray, index + 1, array.length - index);

    return newArray;

}

public static int growSize(int currentSize) {

    //扩容计算规则，当前容量小于5返回8，否则返回2倍的容量

    return currentSize <= 4 ? 8 : currentSize * 2;

}

既然遇到了gc，那再进入gc方法看看SparseArray是如何gc回收数据的：

private void gc() {

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

    int n = mSize; //n代表gc前数组的长度；

    int o = 0;

    int[] keys = mKeys;

    Object[] values = mValues;

    for (int i = 0; i < n; i++) {

        Object val = values[i];

        //遍历元素，如果value不为DELETED，则用前数据放在o上，o的序号表示当前的有效元素下标。每遇到一次DELETED，则i-o的大小+1；

        if (val != DELETED) {

            //之后遇到非DELETED数据，则将后续元素的key和value往前挪

            if (i != o) {

                keys[o] = keys[i];

                values[o] = val;

                values[i] = null;

            }

            o++;

        }

    }

    //此时无垃圾数据，o的序号表示mSize的大小

    mGarbage = false;

    mSize = o;

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

}

它的内部逻辑很简单，就是从头到尾遍历value数组，把每一个不是DELETED的对象都重新放置一遍，覆盖掉前面的DELETED对象。

这里要注意一个非常非常重要的点：

可以看到在循环遍历中做的是将数组前移。因此会存在一个问题，即gc后有效数组长度为o，但是此时，keys.length可能会大于o，那么此时，最后的keys.length-o 个数组元素中仍然存在着key和value且不会消失；但是，由于mSize等于o，此时并不会访问到最后的多个废弃元素。只有在mSize数组范围内的DELETED数据才被称为延迟删除元素，mSize范围外的不会被gc删除，只会被之后的put数组后移覆盖。

下面来一个例子说明一下gc的特点：

 

6.Get方法

public E get(int key) {

    return get(key, null);

}

    /**

     * Gets the Object mapped from the specified key, or the specified Object if no such mapping has been made.

     */

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];

    }

}

 

7.总结

①SparseArray采用了延迟删除的机制，通过将删除KEY的Value设置DELETED，方便之后对该下标的存储进行复用；

②使用二分查找，时间复杂度为O(LogN)，如果没有查找到，那么取反返回左边界，再取反后，左边界即为应该插入的数组下标；

③如果无法直接插入，则根据mGarbage标识（是否有潜在延迟删除的无效数据），进行数据清除，再通过System.arraycopy进行数组后移，将目标元素插入二分查找左边界对应的下标；

④mSize 小于等于keys.length，小于的部分为空数据或者是gc后前移的数据的原数据（也是无效数据），因此二分查找的右边界以mSize为准；mSize包含了延迟删除后的元素个数；

⑤如果遇到频繁删除，不会触发gc机制，导致mSize 远大于有效数组长度，造成性能损耗;

⑥根据源码,可能触发gc操作的方法有(1、put；2、与index有关的所有操作，setValueAt()等；3、size()方法；)

⑦mGarbage为true不一定有无效元素，因为可能被删除的元素恰好被新添加的元素覆盖；

 

根据SparseArray的这些特点，可以分析出其使用场景：

key为整型；

不需要频繁的删除；

元素个数相对较少；

 

8.SparseArray与HashMap

①SparseArray采用的不是哈希算法；HashMap采用的是哈希算法

②SparseArray采用的是两个一维数组分别用于存储键和值；HashMap采用的是一维数组+单向链表

③SparseArray key只能是int类型；HashMap的key可以是任何类型

④SparseArray key是有序存储（升序）；HashMap的key无序

⑤SparseArray默认容量是10；HashMap默认容量是16

⑥SparseArray内存使用要优于HashMap，因为SparseArray的key是int类型，而HashMap的key是Object，并且SparseArray中value的存储不像HashMap一样需要额外的一个实体类Node/Entey进行封装

⑦SparseArray查找元素总体而言比HashMap要逊色，因为SparseArray查找是需要经过二分法的过程，而HashMap不存在冲突的情况下其key处的hash对应的下标就可以直接取到值

针对以上SparseArray与HashMap的比较，采用SparseArray还是HashMap，建议根据如下需求选取：

①如果对内存要求比较高，而对查询效率没什么大的要求，可以使用SparseArray

②数据在百级别的，SparseArray比HashMap更有优势

③要求key是int类型的，使用SparseArray，因为HashMap会对int自动装箱变成Integer类型

④要求key是有序且是升序的用SparseArray