Android Studio说：使用HashMap不如使用SparseArray？

/   今日科技快讯   /

昨日，IDC根据中国智能手机市场月度跟踪报告，发布了我国5G手机市场的目前竞争格局。IDC报告显示，首批5G终端的竞争性布局已经开始，2019年第三季度中国5G手机整体出货量约48.5万部，在市场份额方面vivo占比超过了54.3%，其次是三星、华为、小米。

/   作者简介   /

本篇文章来自叶志陈的投稿，分享了他对SparseArray的相关理解，相信会对大家有所帮助！同时也感谢作者贡献的精彩文章。

叶志陈的博客地址：

https://juejin.im/user/57c2ea9befa631005abd00c6

/   前言   /

使用Android Studio作为IDE的开发者可能会遇到一个现象，就是在代码中如果声明了Map<Integer, Object>类型的变量的话，Android Studio会提示：Use new SparseArray<Object>(...) instead for better performance ...，意思就是用SparseArray<Object>性能更优，可以用来替代HashMap。这里就来介绍下SparseArray的内部原理。

/   正文   /

基本概念

先看下SparseArray的使用方式：

SparseArray<String> sparseArray = new SparseArray<>();
sparseArray.put(100, "leavesC");
sparseArray.remove(100);
sparseArray.get(100);
sparseArray.removeAt(29);

SparseArray< E >相当于Map< Integer,E > ，key值固定为int类型，在初始化时只需要声明Value的数据类型即可，其内部用两个数组分别来存储Key列表和Value列表：int[] mKeys和Object[] mValues。

mKeys和mValues通过如下方式对应起来：

• 假设要向SparseArray存入key为 10，value为200的键值对，则先将10存到mKeys中，假设 10 在mKeys中对应的索引值是index ，则将value存入 mValues[index]中

• mKeys中的元素值按照递增的形式存放，每次存放新的键值对时都通过二分查找方法来对mKeys进行排序

最重要的一点就是SparseArray避免了Map每次存取值时的装箱拆箱操作，Key值都是基本数据类型int，这有利于提升性能。

全局变量

布尔变量mGarbage也是SparseArray的一个优化点之一，用于标记当前是否有待垃圾回收(GC)的元素，当该值被置为true时，即意味着当前状态需要进行垃圾回收，但回收操作并不马上进行，而是在后续操作中再统一进行。

   //数组元素在没有外部指定值时的默认元素值
    private static final Object DELETED = new Object();
    //用于标记当前是否有待垃圾回收(GC)的元素
    private boolean mGarbage = false;
    private int[] mKeys;
    private Object[] mValues;
    //当前集合元素大小
    //该值并不一定是时时处于正确状态，因为有可能出现只删除 key 和 value 两者之一的情况
    //所以在调用 size() 方法前都需要进行 GC
    private int mSize;

构造函数

key数组和value数组的默认大小都是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;
}

添加元素

添加元素的方法有几个，主要看put(int key, E value)方法，当中用到了ContainerHelpers类提供的二分查找方法：binarySearch，用于查找目标key在mKeys中的当前索引（已有改key）或者是目标索引（没有该key）。

binarySearch方法的返回值分为两种情况：

1. 如果mKeys中存在对应的key，则直接返回对应的索引值

2. 如果mKeys中不存在对应的key

2.1 假设mKeys中存在值比key大且大小与key最接近的值的索引为presentIndex，则此方法的返回值为~presentIndex。

2.2 如果mKeys中不存在比key还要大的值的话，则返回值为~mKeys.length。

   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
            }
        }
        return ~lo;  // value not present
    }

可以看到，即使在 mKeys 中不存在目标 key，但其返回值也指向了应该让 key 存入的位置。通过将计算出的索引值进行 ~ 运算，则返回值一定是 0 或者负数，从而与“找得到目标key的情况（返回值大于0）”的情况区分开。

从这个可以看出该方法的巧妙之处，单纯的一个返回值就可以区分出多种情况，且通过这种方式来存放数据可以使得 mKeys 的内部值一直是按照值递增的方式来排序的。

    public void put(int key, E value) {
        //用二分查找法查找指定 key 在 mKeys 中的索引值
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
        //找得到则直接赋值
        if (i >= 0) {
            mValues[i] = value;
        } else {
            i = ~i;
            //如果目标位置还未赋值，则直接存入数据即可，对应的情况是 2.1
            if (i < mSize && mValues[i] == DELETED) {
                mKeys[i] = key;
                mValues[i] = value;
                return;
            }
            //以下操作对应 2.1、2.2 两种情况：
            if (mGarbage && mSize >= mKeys.length) {
                gc();
                //GC 后再次进行查找，因为值可能已经发生变化了
                i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
            }
            //通过复制或者扩容数组，将数据存放到数组中
            mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);
            mValues = GrowingArrayUtils.insert(mValues, mSize, i, value);
            mSize++;
        }
    }

移除元素

上文说了，布尔变量mGarbage用于标记当前是否有待垃圾回收(GC)的元素，当该值被置为true时，即意味着当前状态需要进行垃圾回收，但回收操作并不马上进行，而是在后续操作中再完成。以下几个方法在移除元素时，都是只切断了mValues中的引用，而mKeys并没有进行回收，这个操作会留到gc()进行处理。

  //如果存在 key 对应的元素值，则将其移除
    public void delete(int key) {
        //用二分查找法查找指定 key 在 mKeys 中的索引值
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
        if (i >= 0) {
            if (mValues[i] != DELETED) {
                mValues[i] = DELETED;
                //标记当前需要进行垃圾回收
                mGarbage = true;
            }
        }
    }

    //和 delete 方法基本相同，差别在于会返回 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 查找相应的元素值，查找不到则返回默认值
    @SuppressWarnings("unchecked")
    public E get(int key, E valueIfKeyNotFound) {
        //用二分查找法查找指定 key 在 mKeys 中的索引值
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
        //如果找不到该 key 或者该 key 尚未赋值，则返回默认值
        if (i < 0 || mValues[i] == DELETED) {
            return valueIfKeyNotFound;
        } else {
            return (E) mValues[i];
        }
    }

    //根据 value 查找对应的索引值
    public int indexOfValue(E value) {
        if (mGarbage) {
            gc();
        }
        for (int i = 0; i < mSize; i++) {
            if (mValues[i] == value) {
                return i;
            }
        }
        return -1;
    }

    //与 indexOfValue 方法类似，但 indexOfValue 方法是通过比较 == 来判断是否同个对象
    //而此方法是通过 equals 方法来判断是否同个对象
    public int indexOfValueByValue(E value) {
        if (mGarbage) {
            gc();
        }
        for (int i = 0; i < mSize; i++) {
            if (value == null) {
                if (mValues[i] == null) {
                    return i;
                }
            } else {
                if (value.equals(mValues[i])) {
                    return i;
                }
            }
        }
        return -1;
    }

    //省略其它几个方法

垃圾回收

因为SparseArray中可能会出现只移除value和value两者之一的情况，导致数组中存在无效引用，因此gc()方法就用于移除无效引用，并将有效的元素值位置合并在一起。

   private void gc() {
        int n = mSize;
        //o 值用于表示 GC 后的元素个数
        int o = 0;
        int[] keys = mKeys;
        Object[] values = mValues;
        for (int i = 0; i < n; i++) {
            Object val = values[i];
            //元素值非默认值 DELETED ，说明该位置可能需要移动数据
            if (val != DELETED) {
                //以下代码片段用于将索引 i 处的值赋值到索引 o 处
                //所以如果 i == o ，则不需要执行代码了
                if (i != o) {
                    keys[o] = keys[i];
                    values[o] = val;
                    values[i] = null;
                }
                o++;
            }
        }
        mGarbage = false;
        mSize = o;
    }

/   结语   /

从上文的解读来看，SparseArray的主要优势有以下几点：

• 避免了基本数据类型的装箱拆箱操作

• 和Map每个存储结点都是一个类对象不同，SparseArray不需要用于包装的的结构体，单个元素的存储成本更加低廉

• 在数据量不大的情况下，查找效率较高（二分查找法）

• 延迟了垃圾回收的时机，只在需要的时候才一次进进行

劣势有以下几点：

• 插入新元素可能会导致移动大量的数组元素

• 数据量较大时，查找效率（二分查找法）会明显降低
  

SparseArray.java的完整详细源码注解地址如下：

https://github.com/leavesC/JavaKotlinAndroidGuide/blob/master/android_collections/SparseArray.java

推荐阅读：