Android内存优化之取代HashMap(SparseArray和ArrayMap解析)

看过了内存优化的文章,了解到在Android里为了节约内存,应该尽量避免使用HashMap.

今天的主角是SparseArray和ArrayMap.下面我打算从源码的角度去分析为什么我们要取代HashMap.主要是从三个方法put(),remove(),get()进行分析.

1.SpareArray:

SparseArray仅使用于用int值做key的键值对,他主要是通过两个数组去存储数据

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

mKeys[]用于存储key,mValues[]用于存储对应的value.

首先看下他的put方法

public void put(int key, E value) {
//通过二分法找到下标
int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
//如果已存在就直接赋值取代
if (i >= 0) {
mValues[i] = value;
} else {
i = ~i;
if (i < mSize && mValues[i] == DELETED) {
mKeys[i] = key;
mValues[i] = value;
return;
}

//省略清理数组的代码

mKeys[i] = key;
mValues[i] = value;
mSize++;
}
}

再看他的获取方式get()方法

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

用二分查找法找下标,没什么好说的

看看remove()方法,直接调用了delete():

public void delete(int key) {
int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

if (i >= 0) {
if (mValues[i] != DELETED) {
mValues[i] = DELETED;
mGarbage = true;
}
}
}

删除的时候用一个叫DELETED的Object对象替换原对象

private static final Object DELETED = new Object();

然后会通过清理数组的代码去整合数组,代码如下

private void gc() {
int n = mSize;
int o = 0;
int[] keys = mKeys;
Object[] values = mValues;

for (int i = 0; i < n; i++) {
Object val = values[i];
if (val != DELETED) {
if (i != o) {
keys[o] = keys[i];
values[o] = val;
values[i] = null;
}
o++;
}
}

mGarbage = false;
mSize = o;
}

SparseArray总结一下,他的核心使用二分算法去查找,效率很高,需要的内存也不多,就两个数组,因此这个是最节约内存的(后面会有测试数据).

2.ArrayMap

如果key不能是int的,那就可以考虑用ArrayMap去存储键值对

put()方法:

public V put(K key, V value) {
final int hash;
int index;
if (key == null) {
hash = 0;
index = indexOfNull();
} else {
//查找index里面是用二分查找法
hash = key.hashCode();
index = indexOf(key, hash);
}
//
if (index >= 0) {
index = (index<<1) + 1;
final V old = (V)mArray[index];
mArray[index] = value;
return old;
}

//省略清理数组的代码

mHashes[index] = hash;
mArray[index<<1] = key;
mArray[(index<<1)+1] = value;
mSize++;
return null;
}

可以看出ArrayMap主要由两个数组来存储键值对,分别是mHashes[]用存储key对应的hashcode,mArray[]用来存储key和value(通过移位操作找到下标,由于要存储两个东西,所以就让index左移一位,就是乘以2嘛,从而达到用一个数组同时存储key和value).

下面是get()方法:

public V get(Object key) {
final int index = key == null ? indexOfNull() : indexOf(key, key.hashCode());
return index >= 0 ? (V)mArray[(index<<1)+1] : null;
}

用二分算法找到下标然后找出值,很简单.

remove()同理,用二分算法找到index然后移除对应的值,代码如下

public V remove(Object key) {
int index = key == null ? indexOfNull() : indexOf(key, key.hashCode());
if (index >= 0) {
return removeAt(index);
}
return null;
}

总结ArrayMap,他也是用了二分算法(谷歌为什么这么喜欢二分算法),存数据用了两个数组

int[] mHashes;
Object[] mArray;

效率应该跟SparseArray比较接近,但他存储了3个东西,一个是key,一个是key对应的hashcode,还有一个value,所以内存占用应该会比SparseArray多点.

3.HashMap:

一张图看懂HashMap



HashMap其实就是一个数组,这个数组存储着HashMapEntry对象,而HashMapEntry是个链表结构,所以HashMap其实是数组和链表的结合体.

HashMap的成员主要有:

//存储空key的HashMapEntry
transient HashMapEntry<K, V> entryForNullKey;
//核心数组,用于存储对应的HashMapEntry链表
transient HashMapEntry<K, V>[] table;
//用来存储key的集合
private transient Set<K> keySet;
//存储Entry的集合
private transient Set<Entry<K, V>> entrySet;
//存储值的集合
private transient Collection<V> values;

可以看出HashMap的东西还挺多的.

来看put()方法:

@Override
public V put(K key, V value) {
if (key == null) {
//把空的key用专门的一个链表去存储
return putValueForNullKey(value);
}
//得到转换后的hash值
int hash = secondaryHash(key);
HashMapEntry<K, V>[] tab = table;
int index = hash & (tab.length - 1);
//找到index后对对应的HashMapEntry做遍历如果已经存在就返回
for (HashMapEntry<K, V> e = tab[index]; e != null; e = e.next) {
if (e.hash == hash && key.equals(e.key)) {
preModify(e);
V oldValue = e.value;
e.value = value;
return oldValue;
}
}

// No entry for (non-null) key is present; create one
modCount++;
if (size++ > threshold) {
tab = doubleCapacity();
index = hash & (tab.length - 1);
}
addNewEntry(key, value, hash, index);
return null;
}

addNewEntry():

table[index] = new HashMapEntry<K, V>(key, value, hash, table[index]);

在看看get方法():

public V get(Object key) {
if (key == null) {
HashMapEntry<K, V> e = entryForNullKey;
return e == null ? null : e.value;
}

int hash = key.hashCode();
hash ^= (hash >>> 20) ^ (hash >>> 12);
hash ^= (hash >>> 7) ^ (hash >>> 4);

HashMapEntry<K, V>[] tab = table;
for (HashMapEntry<K, V> e = tab[hash & (tab.length - 1)];
e != null; e = e.next) {
K eKey = e.key;
if (eKey == key || (e.hash == hash && key.equals(eKey))) {
return e.value;
}
}
return null;
}

get()方法就是通过key的hash值拿到index,然后遍历那个位置的HashMapEntry.

最后看看remove方法():

@Override
public V remove(Object key) {
if (key == null) {
//删除空key的方法
return removeNullKey();
}
int hash = secondaryHash(key);
HashMapEntry<K, V>[] tab = table;
int index = hash & (tab.length - 1);
//同样是通过key的hash值找出index,然后遍历那个位置的HashMapEntry
for (HashMapEntry<K, V> e = tab[index], prev = null;
e != null; prev = e, e = e.next) {
if (e.hash == hash && key.equals(e.key)) {
if (prev == null) {
tab[index] = e.next;
} else {
prev.next = e.next;
}
modCount++;
size--;
postRemove(e);
return e.value;
}
}
return null;
}

4.总结

分析完了3个类,我们总结下为什么HashMap比较耗内存.

对比下就会发现,HashMap里面用于存储数据的数组是最多的.其次,性能优化的文章(传送门:http://hukai.me/android-performance-patterns-season-3/)说HashMap会做自动装箱(AutoBoxing boolean,int,float等转换成Boolean，Integer，Float等对象)处理.而SparseArray和ArrayMap都能避免AutoBoxing从而达到节约内存.那篇文章还说,满足两个条件才考虑用ArrayMap:

1.对象个数的数量级最好是千以内

2.数据组织形式包含Map结构

原因是超过一定数量ArrayMap插入和删除效率不高.

光瞎说没有说服力,我们用实际数据测下他们所占的内存大小

首先我们分别为三个类创建一个对象,然后向他们添加1000个Object对象

for (int i = 0 ; i < 10000 ; i++){
mHashMap.put(i,new Object());
}

for (int i = 0 ; i < 10000 ; i++){
mArrayMap.put(i,new Object());
}

for (int i = 0 ; i < 10000 ; i++){
mSparseArray.put(i,new Object());
}

然后用Android Studio自带的内存分析工具看下他们所占内存大小

图1是加1000个的大小,图2是10000个数据的大小





可以看出HashMap,ArrayMap,SparseArray所占内存大小为5:3:2左右.

所以以后我们应该尽量考虑内存优化根据情况尽量不要使用HashMap了.