面试必备：SparseArray源码解析

时间  2019-11-24
标签 面试 必备 sparsearray 源码 解析 栏目 快乐工作 繁體版
原文   原文链接

想看我更多文章:【张旭童的博客】blog.csdn.net/zxt0601
想来gayhub和我gaygayup:【mcxtzhang的Github主页】github.com/mcxtzhangandroid

1 概述

在前文中，咱们已经聊过了HashMap和LinkedHashMap ArrayMap.因此若是没看过，能够先阅读
面试必备：HashMap源码解析（JDK8） ,
面试必备：LinkedHashMap源码解析（JDK8 ，
面试必备：ArrayMap源码解析
今天依旧是看看android sdk的源码。git

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

若是本文中有不正确的结论、说法，请你们提出和我讨论，共同进步，谢谢。面试

2 概要

归纳的说，SparseArray<E>是用于在Android平台上替代HashMap的数据结构,更具体的说，
是用于替代key为int类型，value为Object类型的HashMap。
和ArrayMap相似，它的实现相比于HashMap更加节省空间，并且因为key指定为int类型，也能够节省int-Integer的装箱拆箱操做带来的性能消耗。算法

它仅仅实现了implements Cloneable接口，因此使用时不能用Map做为声明类型来使用。数组

它也是线程不安全的，容许value为null。安全

从原理上说，
它的内部实现也是基于两个数组。
一个int[]数组mKeys，用于保存每一个item的key，key自己就是int类型，因此能够理解hashCode值就是key的值.
一个Object[]数组mValues，保存value。容量和key数组的同样。bash

相似ArrayMap,
它扩容的更合适，扩容时只须要数组拷贝工做，不须要重建哈希表。数据结构

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

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

因此其是按照key的大小排序存储的。

另外，SparseArray为了提高性能，在删除操做时作了一些优化：
当删除一个元素时，并非当即从value数组中删除它，并压缩数组，
而是将其在value数组中标记为已删除。这样当存储相同的key的value时，能够重用这个空间。
若是该空间没有被重用，随后将在合适的时机里执行gc（垃圾收集）操做，将数组压缩，以避免浪费空间。

适用场景：

  • 数据量不大（千之内）
  • 空间比时间重要
  • 须要使用Map，且key为int类型。

示例代码：

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,value为boolean
  • SparseIntArray,value为int
  • SparseLongArray,value为long

他们和SparseArray惟一的区别在于value的类型，SparseArray的value能够是任意类型。而它们是三个常使用的拆箱后的基本类型。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程