面试必备:SparseArray源码解析

本文出自:【张旭童的简书】 (http://www.jianshu.com/users/8e91ff99b072/latest_articles)
想来gayhub和我gaygayup:【mcxtzhang的Github主页】https://github.com/mcxtzhang

1 概述

在前文中,我们已经聊过了HashMapLinkedHashMap ArrayMap.所以如果没看过,可以先阅读
面试必备:HashMap源码解析(JDK8) ,
面试必备:LinkedHashMap源码解析(JDK8
面试必备:ArrayMap源码解析
今天依旧是看看android sdk的源码。

本文将从几个常用方法下手,来阅读SparseArray的源码。
按照从构造方法->常用API(增、删、改、查)的顺序来阅读源码,并会讲解阅读方法中涉及的一些变量的意义。了解SparseArray的特点、适用场景。

如果本文中有不正确的结论、说法,请大家提出和我讨论,共同进步,谢谢。

2 概要

概括的说,SparseArray<E>是用于在Android平台上替代HashMap的数据结构,更具体的说,
是用于替代keyint类型,valueObject类型的HashMap
ArrayMap类似,它的实现相比于HashMap更加节省空间,而且由于key指定为int类型,也可以节省int-Integer装箱拆箱操作带来的性能消耗

它仅仅实现了implements Cloneable接口,所以使用时不能用Map作为声明类型来使用。

它也是线程不安全的,允许value为null。

从原理上说,
它的内部实现也是基于两个数组
一个int[]数组mKeys,用于保存每个item的keykey本身就是int类型,所以可以理解hashCode值就是key的值.
一个Object[]数组mValues,保存value容量key数组的一样

类似ArrayMap,
它扩容的更合适,扩容时只需要数组拷贝工作,不需要重建哈希表

同样它不适合大容量的数据存储。存储大量数据时,它的性能将退化至少50%。

比传统的HashMap时间效率低
因为其会对key从小到大排序,使用二分法查询key对应在数组中的下标。
在添加、删除、查找数据的时候都是先使用二分查找法得到相应的index,然后通过index来进行添加、查找、删除等操作。

所以其是按照key的大小排序存储的。

另外,SparseArray为了提升性能,在删除操作时做了一些优化
当删除一个元素时,并不是立即从value数组中删除它,并压缩数组,
而是将其在value数组中标记为已删除。这样当存储相同的keyvalue时,可以重用这个空间。
如果该空间没有被重用,随后将在合适的时机里执行gc(垃圾收集)操作,将数组压缩,以免浪费空间。

适用场景:

  • 数据量不大(千以内)
  • 空间比时间重要
  • 需要使用Map,且keyint类型。

示例代码:

        SparseArray<String> stringSparseArray = new SparseArray<>();
        stringSparseArray.put(1,"a");
        stringSparseArray.put(5,"e");
        stringSparseArray.put(4,"d");
        stringSparseArray.put(10,"h");
        stringSparseArray.put(2,null);

        Log.d(TAG, "onCreate() called with: stringSparseArray = [" + stringSparseArray + "]");

输出:

//可以看出是按照key排序的
onCreate() called with: stringSparseArray = [{1=a, 2=null, 4=d, 5=e, 10=h}]

3 构造函数

    //用于标记value数组,作为已经删除的标记
    private static final Object DELETED = new Object();
    //是否需要GC 
    private boolean mGarbage = false;
    
    //存储key 的数组
    private int[] mKeys;
    //存储value 的数组
    private Object[] mValues;
    //集合大小
    private int mSize;
    
    //默认构造函数,初始化容量为10
    public SparseArray() {
        this(10);
    }
    //指定初始容量
    public SparseArray(int initialCapacity) {
        //初始容量为0的话,就赋值两个轻量级的引用
        if (initialCapacity == 0) {
            mKeys = EmptyArray.INT;
            mValues = EmptyArray.OBJECT;
        } else {
        //初始化对应长度的数组
            mValues = ArrayUtils.newUnpaddedObjectArray(initialCapacity);
            mKeys = new int[mValues.length];
        }
        //集合大小为0
        mSize = 0;
    }

构造函数 无亮点,路过。
关注一下几个变量:

  • 底层数据结构为int[]Object[]类型数组。
  • mGarbage: 是否需要GC
  • DELETED: 用于标记value数组,作为已经删除的标记

4 增 、改

4.1 单个增、改:

    public void put(int key, E value) {
        //利用二分查找,找到 待插入key 的 下标index
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
        //如果返回的index是正数,说明之前这个key存在,直接覆盖value即可
        if (i >= 0) {
            mValues[i] = value;
        } else {
            //若返回的index是负数,说明 key不存在.
            
            //先对返回的i取反,得到应该插入的位置i
            i = ~i;
            //如果i没有越界,且对应位置是已删除的标记,则复用这个空间
            if (i < mSize && mValues[i] == DELETED) {
            //赋值后,返回
                mKeys[i] = key;
                mValues[i] = value;
                return;
            }
            
            //如果需要GC,且需要扩容
            if (mGarbage && mSize >= mKeys.length) {
                //先触发GC
                gc();
                //gc后,下标i可能发生变化,所以再次用二分查找找到应该插入的位置i
                // Search again because indices may have changed.
                i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
            }
            //插入key(可能需要扩容)
            mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);
            //插入value(可能需要扩容)
            mValues = GrowingArrayUtils.insert(mValues, mSize, i, value);
            //集合大小递增
            mSize++;
        }
    }
    //二分查找 基础知识不再详解
    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
            }
        }
        //若没找到,则lo是value应该插入的位置,是一个正数。对这个正数去反,返回负数回去
        return ~lo;  // value not present
    }
    
    //垃圾回收函数,压缩数组
    private void gc() {
        //保存GC前的集合大小
        int n = mSize;
        //既是下标index,又是GC后的集合大小
        int o = 0;
        int[] keys = mKeys;
        Object[] values = mValues;
        //遍历values集合,以下算法 意义为 从values数组中,删除所有值为DELETED的元素
        for (int i = 0; i < n; i++) {
            Object val = values[i];
            //如果当前value 没有被标记为已删除
            if (val != DELETED) {
                //压缩keys、values数组
                if (i != o) {
                    keys[o] = keys[i];
                    values[o] = val;
                    //并将当前元素置空,防止内存泄漏
                    values[i] = null;
                }
                //递增o
                o++;
            }
        }
        //修改 标识,不需要GC
        mGarbage = false;
        //更新集合大小
        mSize = o;
    }

GrowingArrayUtils.insert:

    //
    public static int[] insert(int[] array, int currentSize, int index, int element) {
        //断言 确认 当前集合长度 小于等于 array数组长度
        assert currentSize <= array.length;
        //如果不需要扩容
        if (currentSize + 1 <= array.length) {
            //将array数组内元素,从index开始 后移一位
            System.arraycopy(array, index, array, index + 1, currentSize - index);
            //在index处赋值
            array[index] = element;
            //返回
            return array;
        }
        //需要扩容
        //构建新的数组
        int[] newArray = new int[growSize(currentSize)];
        //将原数组中index之前的数据复制到新数组中
        System.arraycopy(array, 0, newArray, 0, index);
        //在index处赋值
        newArray[index] = element;
        //将原数组中index及其之后的数据赋值到新数组中
        System.arraycopy(array, index, newArray, index + 1, array.length - index);
        //返回
        return newArray;
    }
    //根据现在的size 返回合适的扩容后的容量
    public static int growSize(int currentSize) {
        //如果当前size 小于等于4,则返回8, 否则返回当前size的两倍
        return currentSize <= 4 ? 8 : currentSize * 2;
    }
  • 二分查找,若未找到返回下标时,与JDK里的实现不同,JDK是返回return -(low + 1); // key not found.,而这里是对 低位去反 返回。
    这样在函数调用处,根据返回值的正负,可以判断是否找到index。对负index取反,即可得到应该插入的位置

  • 扩容时,当前容量小于等于4,则扩容后容量为8.否则为当前容量的两倍。和ArrayList,ArrayMap不同(扩容一半),和Vector相同(扩容一倍)。

  • 扩容操作依然是用数组的复制、覆盖完成。类似ArrayList.

5 删

5.1 按照key删除

    //按照key删除
    public void remove(int key) {
        delete(key);
    }
    
    public void delete(int key) {
        //二分查找得到要删除的key所在index
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
        //如果>=0,表示存在
        if (i >= 0) {
            //修改values数组对应位置为已删除的标志DELETED
            if (mValues[i] != DELETED) {
                mValues[i] = DELETED; 
                //并修改 mGarbage ,表示稍后需要GC
                mGarbage = true;
            }
        }
    }

5.2 按照index删除

    public void removeAt(int index) {
        //根据index直接索引到对应位置 执行删除操作
        if (mValues[index] != DELETED) {
            mValues[index] = DELETED;
            mGarbage = true;
        }
    }

5.3 批量删除

    public void removeAtRange(int index, int size) {
    //越界修正
        final int end = Math.min(mSize, index + size);
        //for循环 执行单个删除操作
        for (int i = index; i < end; i++) {
            removeAt(i);
        }
    }

6 查

6.1 按照key查询

    //按照key查询,如果key不存在,返回null
    public E get(int key) {
        return get(key, null);
    }

    //按照key查询,如果key不存在,返回valueIfKeyNotFound
    public E get(int key, E valueIfKeyNotFound) {
        //二分查找到 key 所在的index
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
        //不存在
        if (i < 0 || mValues[i] == DELETED) {
            return valueIfKeyNotFound;
        } else {//存在
            return (E) mValues[i];
        }
    }

6.2 按照下标查询

    public int keyAt(int index) {
    //按照下标查询时,需要考虑是否先GC
        if (mGarbage) {
            gc();
        }

        return mKeys[index];
    }
    
    public E valueAt(int index) {
     //按照下标查询时,需要考虑是否先GC
        if (mGarbage) {
            gc();
        }

        return (E) mValues[index];
    }

6.3查询下标:

    public int indexOfKey(int key) {
     //查询下标时,也需要考虑是否先GC
        if (mGarbage) {
            gc();
        }
        //二分查找返回 对应的下标 ,可能是负数
        return ContainerHelpers.binarySearch(mKeys, mSize, key);
    }
    public int indexOfValue(E value) {
     //查询下标时,也需要考虑是否先GC
        if (mGarbage) {
            gc();
        }
        //不像key一样使用的二分查找。是直接线性遍历去比较,而且不像其他集合类使用equals比较,这里直接使用的 ==
        //如果有多个key 对应同一个value,则这里只会返回一个更靠前的index
        for (int i = 0; i < mSize; i++)
            if (mValues[i] == value)
                return i;

        return -1;
    }
  • 按照value查询下标时,不像key一样使用的二分查找。是直接线性遍历去比较,而且不像其他集合类使用equals比较,这里直接使用的 ==
  • 如果有多个key 对应同一个value,则这里只会返回一个更靠前的index

总结

SparseArray的源码相对来说比较简单,经过之前几个集合的源码洗礼,很轻松就可以掌握大体流程和关键思想:时间换空间

Android sdk中,还提供了三个类似思想的集合:

  • SparseBooleanArray,valueboolean
  • SparseIntArray,valueint
  • SparseLongArray,valuelong

他们和SparseArray唯一的区别在于value的类型SparseArrayvalue可以是任意类型。而它们是三个常使用的拆箱后的基本类型。

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 148,637评论 1 318
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 63,443评论 1 266
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 99,164评论 0 218
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 42,075评论 0 188
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 50,080评论 1 266
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 39,365评论 1 184
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 30,901评论 2 283
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 29,649评论 0 176
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 33,122评论 0 223
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 29,734评论 2 225
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,093评论 1 236
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 27,548评论 2 222
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 32,028评论 3 216
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 25,765评论 0 9
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,291评论 0 178
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 34,162评论 2 239
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 34,293评论 2 242

推荐阅读更多精彩内容