SparseArray解析

注:SparseArray来自于Android源码
问题:
1、什么是SparseArray?
2、SparseArray采用说明数据结构?
3、SparseArray默认容量多大?
4、SparseArray最大容量?每次扩容多少?
5、SparseArray get的原理是?
6、SparseArray put的原理是?
7、SparseArray 查找采用的是什么算法?
8、SparseArray与HashMap的比较,应用场景是?

问题1、什么是SparseArray?

Sparse翻译过来是稀疏、缺少的意思,SparseArray是稀疏的数组?有那么点意思在里面,应用场景是相对稀少的数据,一般是几百以内的数据性能相对HashMap要好,大概提升0-50%的性能。SparseArray是用Integer作为键映射对象。我们看下其关键的注释:

/**
SparseArrays map integers to Objects.   
//...省略
For containers holding up to hundreds of items,the performance difference is not significant, less than 50%
*/
问题2、SparseArray采用说明数据结构?

SparseArray并不像HashMap采用一维数组+单链表结构,而是采用两个一维数组,一个是存储key(int类型),一个是存在value。

private int[] mKeys;
private Object[] mValues;

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

问题3、SparseArray默认容量多大?

答案是10,SparseArray并没有定义默认容量的大小,而是在默认构造函数中 指定其默认容量大小

public SparseArray() {
        this(10);
}
问题4、SparseArray最大容量?每次扩容多少?

SparseArray并不像HashMap一样定义有最大容量是多少,最大可以达到Integer.MAX_VALUE,可能会报oom。每次扩容时如果当前容量小于5则扩容是8,否则hi原容量的2倍,看put原理时会知道为什么。

问题5、SparseArray get的原理是?

先看get源码:

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

public E get(int key, E valueIfKeyNotFound) {
        //通过二分法找在mkeys数组中找到匹配的key的下标
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
        
        if (i < 0 || mValues[i] == DELETED) {
            //如果没找到对应的值,则返回默认值null
            return valueIfKeyNotFound;
        } else {
            //返回找到匹配的值
            return (E) mValues[i];
        }
}

因为SparseArray采用的是两个一维数组分别存储键和值,所以根据key找到下标,就可以使用该下标取出对应的值。其中找到key对应的下标采用的是二分法。

问题6、SparseArray put的原理是?

先看起源码:

public void put(int key, E value) {
       //通过二分法找到key所在的下标
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i >= 0) {
            //如果i >= 0 代表当前以及存在key及其对应的值,则直接替换value即可
            mValues[i] = value;
        } else {
            //如果i < 0 代表当前并不存在key,意思就是添加新的键值对
            // i 取反操作,得到要添加的下标,为什么取反?后面进行分析会进行讲解
            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);
            }
            //在存储按键数组中下标为i,添加新键为key
            mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);
            //在存储值数组中下标为i,添加新值为value
            mValues = GrowingArrayUtils.insert(mValues, mSize, i, value);
            //真实数据个数加1
            mSize++;
        }
}


//GrowingArrayUtils.java
public static <T> T[] insert(T[] array, int currentSize, int index, T 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;
        }
        
        //如果容量不足,先进行扩容生成新的数组newArray
        @SuppressWarnings("unchecked")
        T[] newArray = ArrayUtils.newUnpaddedArray((Class<T>)array.getClass().getComponentType(),
                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;
    }

通过上述put源码,我们可以总结如下:
1、通过二分法找出key的下标,判断是否已经存在要添加的key,如果找到直接替换对应的value
2、如果不存在要添加的key,且容量充足,直接添加
3、如果不存在要添加的key,则分别对存储键和值的两个数组进行扩容并添加元素
透过put的操作可以得到的信息有:
1、SparseArray是允许插入value为null的情况,因为key是int类型,所以不存在key为null的情况
2、SparseArray添加元素时key是确保是有序的,是按key的大小进行排序的,因为其采用的二分法现在找到对应key对应的下标
3、SpareseArray默认每次扩容是原容量的2倍(特殊情况如果当前容量小5则扩容到8)
好,我们回到添加元素时,为什么对二分法取得下标i取反操作?我们先看下其源码实现:

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) {
                /**
                如果数组中间处的值比要找的值小,代表要找的值
                在数组的中后部部分,所以当前下标取值为mid + 1
                */
                lo = mid + 1;
            } else if (midVal > value) {
                /**
                如果数组中间处的值比要找的值大,代表要找的值
                在数组的前中部部分,所以当前下标取值为mid - 1
                */
                hi = mid - 1;
            } else {
                //数组中间处的值与要找的值相等,直接返回数组中部的下标mid
                return mid;  // value found
            }
        }
        //上述没找到匹配值的时候,lo最终变成的时候要添加元素的位置
        /**此处取反,会变成负数,负数表示没找到,重新取反时代表的是要添加元素的位置
        */
        return ~lo;  // value not present
    }

上述是二分法的实现,如果不懂什么是二分法,先去了解什么是二分法。
有别于其他二分法的实现的是当它没有找到匹配的元素时,返回的不是-1,而是要添加元素位置取反之后的值,取反变成负数,所以当此二分法返回负数时代表原数组中不存在对应的值,意思是要添加新的元素,添加时再取反就变回了要添加元素的下标位置。
此处的二分法返回值i取反有两个意思:
1、负数代表没有找打元素,意思是添加元素
2、要添加元素的下标位置
如果还是不明白,自己再好好想想。

问题7、SparseArray 查找采用的是什么算法?

get和put源码分析时已经很明确了,其采用的是二分法算法

问题8、SparseArray与HashMap的比较,应用场景是?

1、SparseArray不是采用的不是哈希算法,HashMap采用的是哈希算法
2、SparseArray采用的是两个一维数组分别用于存储键和值,HashMap采用的是一维数组+单向链表
3、SparseArray key只能是int类型,而HashMap可以任何类型
4、SparseArray key是有序存储(升序),而HashMap不是
5、SparseArray 默认容量是10,而HashMap默认容量是16
6、SparseArray 默认每次扩容是2倍于原来的容量,而HashMap默认每次扩容时是原容量*0.75倍
7、SparseArray 内存使用要优于HashMap,因为:

  • SparseArray key是int类型,而HashMap是Object
  • SparseArray value的存储被不像HashMap一样需要额外的需要一个实体类(Node)进行包装

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

针对上面与HashMap的比较,采用SparseArray还是HashMap,建议根据如下需求选取:
1、如果对内存要求比较高,而对查询效率没什么大的要求,可以是使用SparseArray
2、数量在百级别的SparseArray比HashMap有更好的优势
3、要求key是int类型的,因为HashMap会对int自定装箱变成Integer类型
4、要求key是有序的且是升序

推荐阅读更多精彩内容