Android内存优化（使用SparseArray和ArrayMap取代HashMap）

在Android开发时，我们使用的大部分都是Java的api，比方HashMap这个api，使用率非常高，可是对于Android这样的对内存非常敏感的移动平台，非常多时候使用一些java的api并不能达到更好的性能，相反反而更消耗内存，所以针对Android这样的移动平台，也推出了更符合自己的api，比方SparseArray、ArrayMap用来取代HashMap在有些情况下能带来更好的性能提升。

介绍它们之前先来介绍一下HashMap的内部存储结构。就明确为什么推荐使用SparseArray和ArrayMap

HashMap

HashMap内部是使用一个默认容量为16的数组来存储数据的，而数组中每个元素却又是一个链表的头结点。所以，更准确的来说，HashMap内部存储结构是使用哈希表的拉链结构（数组+链表），如图： 
这样的存储数据的方法叫做拉链法 
这里写图片描写叙述 
且每个结点都是Entry类型，那么Entry是什么呢？我们来看看HashMap中Entry的属性：

final K key;
V value;
final int hash;
HashMapEntry<K, V> next;

从中我们得知Entry存储的内容有key、value、hash值、和next下一个Entry。那么。这些Entry数据是按什么规则进行存储的呢？就是通过计算元素key的hash值，然后对HashMap中数组长度取余得到该元素存储的位置。计算公式为hash(key)%len，比方：假设hash(14)=14,hash(30)=30,hash(46)=46，我们分别对len取余，得到 
hash(14)%16=14，hash(30)%16=14，hash(46)%16=14，所以key为14、30、46的这三个元素存储在数组下标为14的位置，如： 
这里写图片描写叙述 
从中能够看出。假设有多个元素key的hash值相同的话。后一个元素并不会覆盖上一个元素。而是採取链表的方式，把之后加进来的元素加入链表末尾。从而攻克了hash冲突的问题。由此我们知道HashMap中处理hash冲突的方法是链地址法，在此补充一个知识点，处理hash冲突的方法有下面几种：

  1. 开放地址法
  2. 再哈希法
  3. 链地址法
  4. 建立公共溢出区

说到这里，重点来了，我们知道HashMap中默认的存储大小就是一个容量为16的数组，所以当我们创建出一个HashMap对象时，即使里面没有不论什么元素。也要分别一块内存空间给它，并且，我们再不断的向HashMap里put数据时，当达到一定的容量限制时（这个容量满足这样的一个关系时候将会扩容：HashMap中的数据量>容量*载入因子，而HashMap中默认的载入因子是0.75），HashMap的空间将会扩大，并且扩大后新的空间一定是原来的2倍，我们能够看put()方法中有这样的一行代码：

int newCapacity = oldCapacity * 2;

所以，重点就是这个，仅仅要一满足扩容条件，HashMap的空间将会以2倍的规律进行增大。

假如我们有几十万、几百万条数据，那么HashMap要存储完这些数据将要不断的扩容，并且在此过程中也须要不断的做hash运算，这将对我们的内存空间造成非常大消耗和浪费。并且HashMap获取数据是通过遍历Entry[]数组来得到相应的元素，在数据量非常大时候会比較慢，所以在Android中，HashMap是比較费内存的，我们在一些情况下能够使用SparseArray和ArrayMap来取代HashMap。

SparseArray

SparseArray比HashMap更省内存，在某些条件下性能更好，主要是由于它避免了对key的自己主动装箱（int转为Integer类型），它内部则是通过两个数组来进行数据存储的。一个存储key，另外一个存储value，为了优化性能，它内部对数据还採取了压缩的方式来表示稀疏数组的数据，从而节约内存空间。我们从源代码中能够看到key和value各自是用数组表示：

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

我们能够看到，SparseArray仅仅能存储key为int类型的数据。同一时候，SparseArray在存储和读取数据时候，使用的是二分查找法，我们能够看看：

 public void put(int key, E value) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
        ...
        }
 public E get(int key, E valueIfKeyNotFound) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
        ...
        }

也就是在put加入数据的时候。会使用二分查找法和之前的key比較当前我们加入的元素的key的大小，然后依照从小到大的顺序排列好，所以，SparseArray存储的元素都是按元素的key值从小到大排列好的。 
而在获取数据的时候，也是使用二分查找法推断元素的位置，所以，在获取数据的时候非常快，比HashMap快的多，由于HashMap获取数据是通过遍历Entry[]数组来得到相应的元素。

加入数据

public void put(int key, E value)

删除数据

 public void remove(int key)

or

public void delete(int key)

事实上remove内部还是通过调用delete来删除数据的

获取数据

public E get(int key)

or

public E get(int key, E valueIfKeyNotFound)

该方法可设置假设key不存在的情况下默认返回的value

特有方法

在此之外，SparseArray还提供了两个特有方法。更方便数据的查询： 
获取相应的key：

public int keyAt(int index)

获取相应的value：

public E valueAt(int index)

SparseArray应用场景：

虽说SparseArray性能比較好，可是由于其加入、查找、删除数据都须要先进行一次二分查找。所以在数据量大的情况下性能并不明显，将减少至少50%。

满足下面两个条件我们能够使用SparseArray取代HashMap：

  • 数据量不大，最好在千级以内
  • key必须为int类型，这中情况下的HashMap能够用SparseArray取代：
HashMap<Integer, Object> map = new HashMap<>();
用SparseArray取代:
SparseArray<Object> array = new SparseArray<>();

ArrayMap

这个api的资料在网上能够说差点儿没有，然并卵，仅仅能看文档了 
ArrayMap是一个<key,value>映射的数据结构，它设计上很多其他的是考虑内存的优化，内部是使用两个数组进行数据存储，一个数组记录key的hash值。另外一个数组记录Value值。它和SparseArray一样。也会对key使用二分法进行从小到大排序，在加入、删除、查找数据的时候都是先使用二分查找法得到相应的index，然后通过index来进行加入、查找、删除等操作，所以，应用场景和SparseArray的一样，假设在数据量比較大的情况下，那么它的性能将退化至少50%。

加入数据

public V put(K key, V value)

获取数据

public V get(Object key)

删除数据

public V remove(Object key)

特有方法

它和SparseArray一样相同也有两个更方便的获取数据方法：

public K keyAt(int index)
public V valueAt(int index)

ArrayMap应用场景

  • 数据量不大，最好在千级以内
  • 数据结构类型为Map类型
ArrayMap<Key, Value> arrayMap = new ArrayMap<>();

【注】：假设我们要兼容aip19下面版本号的话，那么导入的包须要为v4包

import android.support.v4.util.ArrayMap;



通常情况下，当我们用HashMap存储数据时，Android studio会建议我们使用SparseArray，最近公司项目使用到了，所以就来探究一下

构造器
1.无参构造器：SparseArray()，源码如下：
/**
* Creates a new SparseArray containing no mappings.
*/
public SparseArray() {
this(10);
}

2.带参构造器：SparseArray(int initialCapacity)，源码如下：
/**
* Creates a new SparseArray containing no mappings that will not
* require any additional memory allocation to store the specified
* number of mappings. If you supply an initial capacity of 0, the
* sparse array will be initialized with a light-weight representation
* not requiring any additional array allocations.
*/
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;
}


从构造器看，有两个构造器，一个是你自己设置容器大小，一个是默认，默认值为10
下面着重看看它的几个方法

一.添加键值对
1.public void put(int key, E value) ,源码如下：
/**
* Adds a mapping from the specified key to the specified value,
* replacing the previous mapping from the specified key if there
* was one.
*/
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;
}

if (mGarbage && mSize >= mKeys.length) {
gc();

// Search again because indices may have changed.
i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
}

mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);
mValues = GrowingArrayUtils.insert(mValues, mSize, i, value);
mSize++;
}
}


2.public void append(int key, E value) ，源码如下：
/**
* Puts a key/value pair into the array, optimizing for the case where
* the key is greater than all existing keys in the array.
*/
public void append(int key, E value) {
if (mSize != 0 && key <= mKeys[mSize - 1]) {
put(key, value);
return;
}

if (mGarbage && mSize >= mKeys.length) {
gc();
}

mKeys = GrowingArrayUtils.append(mKeys, mSize, key);
mValues = GrowingArrayUtils.append(mValues, mSize, value);
mSize++;
}

可以看出，采用的是二分法存储，存储数据是按键的值从小到大的顺序排列的。
二.查
1.根据见键查询值
public E get(int key) //查不到时为null
public E get(int key, E valueIfKeyNotFound) //valueIfKeyNotFound 当查不到时的默认值
1
2
源码如下：
/**
* Gets the Object mapped from the specified key, or <code>null</code>
* if no such mapping has been made.
*/
public E get(int key) {
return get(key, null);
}

/**
* Gets the Object mapped from the specified key, or the specified Object
* if no such mapping has been made.
*/
@SuppressWarnings("unchecked")
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];
}
}
.
.
.
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
}

2.查看某个位置的键：
public int keyAt(int index)
1
3.查看某个位置的值：
public E valueAt(int index)
1
4.根据Key查询键所在的位置,没有则返回负数
public int indexOfKey(int key)
1
5.根据Value查询值所在的位置,没有则返回-1
public int indexOfValue(E value)
1
三.删除
public void delete(int key)
public void remove(int key)
public void removeAt(int index)

四.修改
public void setValueAt(int index, E value) //比较常用
public void put(int key, E value)

SparseArray,SparseBooleanArray和SparseIntArray

因此，SparseArray 的 key 必须为 int 类型。

SparseArray 默认的 value 可以为任意类型，因此根据 value 类型不同，又可以细分派生出 SparseIntArray（key 为 int， value 为int）、SparseBooleanArray（key 为 int， value 为 boolean）、SparseLongArray（key 为 int， value 为 long） 等，使用方法与 SparseArray 大同小异。其中，SparseLongArray 如下：

前面说了， SparseArray 的 key 必须为 int 类型，而对于“特殊的 int 类型” — long ， 也有相应的类来处理，这就是LongSparesArray：

可以看到，LongSparesArray 的 key 为 long 类型。

总结：
SparseArray ：key为 int， value 任意
SparseLongArray：key 为 int， value 为 long
LongSparesArray： key 为 long ， value 任意
（Long 在前，key 为 long；Long 在后，value 为 long）

####Android开发中高效的数据结构
android开发中，在java2ee或者android中常用的数据结构有Map,List,Set，但android作为移动平台，有些api（很多都是效率问题）显然不够理想，本着造更好轮子的精神，android团队编写了自己的api用来代替java api

1、SimpleArrayMap<K,V>与ArrayMap<K,V>

实质上ArrayMap继承自SimpleArrayMap,主要是为了实现像HashMap一样的api方法，让习惯使用HashMap的开发者感觉不到差异，本质上是SimpleArrayMap+Map的再封装。

一般来说使用这2个类主要来代替HashMap，因为他们比HashMap更加高效，对内存也进行了优化。

2、SparseArray<T>与SparseArrayCompat<T>和LongSparseArray<T>

这3个类中，前2个基本上是同一类，只不过第二个类有removeAt方法，第三个是Long类型的。

这3个类也是用来代替HashMap,只不过他们的键(key)的类型是整型Integer或者Long类型，在实际开发中，如月份缩写的映射，或者进行文件缓存映射，viewHolder都特别适用

3、AtomicFile

AtomicFile首先不是用来代替File的，而是作为File的辅助类从在， AtomicFile的作用是实现事务性原子操作，即文件读写必须完整，适合多线程中的文件读写操作。

用来实现多线程中的文件读写的安全操作

----
#####用SparseArray代替HashMap
SparseArray是android提供的一个工具类，它可以用来替代hashmap进行对象的存储，其内部实现了一个矩阵压缩算法，很适合存储稀疏矩阵的。

PS:support包中还提供了兼容的类SparseArrayCompat,基本和SparseArray是同一个类，只不过第二个类有removeAt方法

针对源码的详细分析：[http://stormzhang.com/android/2013/08/01/android-use-sparsearray-for-performance-optimization/](http://stormzhang.com/android/2013/08/01/android-use-sparsearray-for-performance-optimization/ "http://stormzhang.com/android/2013/08/01/android-use-sparsearray-for-performance-optimization/")

一、和Hashmap的对比

既然android推荐用这个东西，自然有用它的道理。其内部实现了压缩算法，可以进行矩阵压缩，大大减少了存储空间，节约内存。此外它的查找算法是二分法，提高了查找的效率。

替换原则：

1>

如果用到了： HashMap<Integer, E> hashMap = new HashMap<Integer, E>();

可以替换为：SparseArray<E> sparseArray = new SparseArray<E>();

2>

如果用到了：HashMap<Integer, Boolean> hashMap = new HashMap<Integer, Boolean>

可以替换为：SparseBooleanArray array = new SparseBooleanArray();

3>

如果用到了：HashMap<Integer, Integer> hashMap = new HashMap<Integer, Integer>

可以替换为：SparseIntArray array = new SparseIntArray();

二、用法

既然是键值对那么就有增删改查，但要记得先初始化：

        Button btn = null; // 测试view，无意义
        Button btn02 = null; // 测试view，表示新增的对象
        final int KEY = 1;

        /*
         * SparseArray指的是稀疏数组(Sparse
         * array)，所谓稀疏数组就是数组中大部分的内容值都未被使用（或都为零），在数组中仅有少部分的空间使用
         * 。因此造成内存空间的浪费，为了节省内存空间，并且不影响数组中原有的内容值，我们可以采用一种压缩的方式来表示稀疏数组的内容。
         */
        SparseArray<View> array = new SparseArray<View>(); 

2.1 增加数据

　　　　　/* 增加数据 */
        //public void put(int key, E value) {}
        array.put(KEY, btn);
        //public void append(int key, E value){}
        array.append(KEY, btn);


 

2.2 修改数据


　　　　  /* 修改数据 */
        //在put数据之前，会先查找要put的数据是否已经存在，如果存在就是修改，不存在就添加。
        //public void put(int key, E value)
        array.put(KEY, btn);
        //public void setValueAt(int index, E value)
        array.setValueAt(KEY, btn02); 

2.3 查找数据

　　　　  /* 查找数据 */
        //public E get(int key)
        array.get(KEY);
        //public E get(int key, E valueIfKeyNotFound)
        //其中get(int key)也只是调用了 get(int key,E valueIfKeyNotFound),最后一个从传参的变量名就能看出，传入的是找不到的时候返回的值.get(int key)当找不到的时候，默认返回null。
        array.get(KEY, btn); // 如果这个key找不到value，那么就返回第二个参数。和default value一样


2.4 通过位置，查找键的值


　　　　  // 查看第几个位置的键：
        //public int keyAt(int index)
        array.keyAt(1); // 如果找不到就返回-1
 

2.5 通过位置，查找值

        // 查看第几个位置的值：
        //public E valueAt(int index)
        array.valueAt(1);
        // 查看值所在位置，没有的话返回-1：
        //public int indexOfValue(E value)
        array.indexOfValue(btn);

三、测试代码

    package com.kale.pictest;
    
    import android.app.Activity;
    import android.os.Bundle;
    import android.util.Log;
    import android.util.SparseArray;
    import android.util.SparseBooleanArray;
    import android.view.View;
    import android.widget.Button;
    
    /**
     * @author:
     * @description  :
     * @web : http://stormzhang.com/android/2013/08/01/android-use-sparsearray-for-performance-optimization/
     * @date  :2015年1月19日
     */
    public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        Log.d("TAG", "Max memory is " + maxMemory + "KB");
        
        
        Button btn = null; // 测试view，无意义
        Button btn02 = null; // 测试view，表示新增的对象
        final int KEY = 1;

        /*
         * SparseArray指的是稀疏数组(Sparse
         * array)，所谓稀疏数组就是数组中大部分的内容值都未被使用（或都为零），在数组中仅有少部分的空间使用
         * 。因此造成内存空间的浪费，为了节省内存空间，并且不影响数组中原有的内容值，我们可以采用一种压缩的方式来表示稀疏数组的内容。
         */
        SparseArray<View> array = new SparseArray<View>();
        
        /* 增加数据 */
        //public void put(int key, E value) {}
        array.put(KEY, btn);
        //public void append(int key, E value){}
        array.append(KEY, btn);
        
        /* 修改数据 */
        //在put数据之前，会先查找要put的数据是否已经存在，如果存在就是修改，不存在就添加。
        //public void put(int key, E value)
        array.put(KEY, btn);
        //public void setValueAt(int index, E value)
        array.setValueAt(KEY, btn02);
        
        /* 查找数据 */
        //public E get(int key)
        array.get(KEY);
        //public E get(int key, E valueIfKeyNotFound)
        //其中get(int key)也只是调用了 get(int key,E valueIfKeyNotFound),最后一个从传参的变量名就能看出，传入的是找不到的时候返回的值.get(int key)当找不到的时候，默认返回null。
        array.get(KEY, btn); // 如果这个key找不到value，那么就返回第二个参数。和default value一样
        
        // 查看第几个位置的键：
        //public int keyAt(int index)
        array.keyAt(1); // 如果找不到就返回-1
        
        // 查看第几个位置的值：
        //public E valueAt(int index)
        array.valueAt(1);
        // 查看值所在位置，没有的话返回-1：
        //public int indexOfValue(E value)
        array.indexOfValue(btn);
        
        SparseBooleanArray d;
    }
    }


测试代码四：

    public class FragmentPagerItemAdapter extends FragmentPagerAdapter {

    private final FragmentPagerItems mPages;
    private final SparseArrayCompat<WeakReference<Fragment>> mHolder;

    public FragmentPagerItemAdapter(FragmentManager fm, FragmentPagerItems pages) {
        super(fm);
        mPages = pages;
        mHolder = new SparseArrayCompat<>(pages.size());
    }

    @Override
    public int getCount() {
        return mPages.size();
    }

    @Override
    public Fragment getItem(int position) {
        return getPagerItem(position).instantiate(mPages.getContext(), position);
    }

    @Override
    public Object instantiateItem(ViewGroup container, int position) {
        Object item = super.instantiateItem(container, position);
        if (item instanceof Fragment) {
            mHolder.put(position, new WeakReference<Fragment>((Fragment) item));
        }
        return item;
    }

    @Override
    public void destroyItem(ViewGroup container, int position, Object object) {
        mHolder.remove(position);
        super.destroyItem(container, position, object);
    }

    @Override
    public CharSequence getPageTitle(int position) {
        return getPagerItem(position).getTitle();
    }

    @Override
    public float getPageWidth(int position) {
        return super.getPageWidth(position);
    }

    public Fragment getPage(int position) {
        final WeakReference<Fragment> weakRefItem = mHolder.get(position);
        return (weakRefItem != null) ? weakRefItem.get() : null;
    }

    protected FragmentPagerItem getPagerItem(int position) {
        return mPages.get(position);
    }

    }

复制代码
 

总结

SparseArray和ArrayMap都差点儿相同，使用哪个呢？ 
假设数据量都在千级以内的情况下：

1、假设key的类型已经确定为int类型。那么使用SparseArray，由于它避免了自己主动装箱的过程，假设key为long类型，它还提供了一个LongSparseArray来确保key为long类型时的使用

2、假设key类型为其他的类型，则使用ArrayMap

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Alex80/p/11276298.html