step1:背景
今天偶然看到了sparseArray,发现其主要是针对<(Integer,obj>的类型进行了优化,何为sparse?是稀疏的意思。指的是对稀疏数组情况的讨论
所谓稀疏数组:
* 就是数组中大部分的内容值都未被使用(或都为零),在数组中仅有少部分的空间使用。因此造成内存空间的浪费,为了节省内存空间,并且不影响数组中原有的内容值,我们可以采用一种压缩的方式来表示稀疏数组的内容。
step2:上源码
- 类结构图
- 构造函数
SparseArray(int)可以指定容量
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 它有两个方法可以添加键值对
- 1.put(int key, E value)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
* 2.append(int key, E value)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 有四个方法可以执行删除操作:
- 1.delete(int key)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
* 2.remove(int key)
- 1
- 2
- 3
- 1
- 2
- 3
* 3. removeAt(int index)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
* 4.removeAtRange(int index, int size)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 1
- 2
- 3
- 4
- 5
- 6
- 7
step3:Util函数支持
put(int key, E value) 中出现了3个函数,现在我们一一解析
1)ContainerHelpers.binarySearch(mKeys, mSize, key);
2)gc();
3)GrowingArrayUtils.insert(mKeys, mSize, i, key);
* ContainerHelpers.binarySearch(mKeys, mSize, key);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- GrowingArrayUtils.insert(mKeys, mSize, i, key);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 3)gc
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
总结:
SparseArray是Android里为(Interger,Object)这样的Hashmap而专门写的类,目的是提高内存效率,其核心是折半查找函数(binarySearch)。注意内存二字很重要,因为它仅仅提高内存效率,而不是提高执行效率,所以也决定它只适用于android系统(内存对android项目有多重要,地球人都知道)。SparseArray有两个优点:1.避免了自动装箱(auto-boxing),2.数据结构不会依赖于外部对象映射。我们知道HashMap 采用一种所谓的“Hash 算法”来决定每个元素的存储位置,存放的都是数组元素的引用,通过每个对象的hash值来映射对象。而SparseArray则是用数组数据结构来保存映射,然后通过折半查找来找到对象。但其实一般来说,SparseArray执行效率比HashMap要慢一点,因为查找需要折半查找,而添加删除则需要在数组中执行,而HashMap都是通过外部映射。但相对来说影响不大,最主要是SparseArray不需要开辟内存空间来额外存储外部映射,从而节省内存。
这就是二者的结构,我们需要看一下二者到底有什么差异...
首先是插入:
HashMap的正序插入:
HashMap<Integer, String>map = new HashMap<Integer, String>(); long start_map = System.currentTimeMillis(); for(int i=0;i<MAX;i++){ map.put(i, String.valueOf(i)); } long map_memory = Runtime.getRuntime().totalMemory(); long end_map = System.currentTimeMillis()-start_map; System.out.println("<---Map的插入时间--->"+end_map+"<---Map占用的内存--->"+map_memory);
执行后的结果:
<---Map的插入时间--->914
<---Map占用的内存--->28598272
SparseArray的正序插入:
SparseArray<String>sparse = new SparseArray<String>(); long start_sparse = System.currentTimeMillis(); for(int i=0;i<MAX;i++){ sparse.put(i, String.valueOf(i)); } long sparse_memory = Runtime.getRuntime().totalMemory(); long end_sparse = System.currentTimeMillis()-start_sparse; System.out.println("<---Sparse的插入时间--->"+end_sparse+"<---Sparse占用的内存--->"+sparse_memory); //执行后的结果: <---Sparse的插入时间--->611 <---Sparse占用的内存--->23281664
我们可以看到100000条数据量正序插入时SparseArray的效率要比HashMap的效率要高.并且占用的内存也比HashMap要小一些..这里的正序插入表示的是i的值是从小到大进行的一个递增..序列取决于i的值,而不是for循环内部如何执行...
通过运行后的结果我们可以发现,SparseArray在正序插入的时候,效率要比HashMap要快得多,并且还节省了一部分内存。网上有很多的说法关于二者的效率问题,很多人都会误认为SparseArray要比HashMap的插入和查找的效率要快,还有人则是认为Hash查找当然要比SparseArray中的二分查找要快得多.
其实我认为Android中在保存<Integer,Value>的时候推荐使用SparseArray的本质目的不是由于效率的原因,而是内存的原因.我们确实看到了插入的时候SparseArray要比HashMap要快.但是这仅仅是正序插入.我们来看看倒序插入的情况.
HashMap倒序插入:
System.out.println("<------------- 数据量100000 散列程度小 Map 倒序插入--------------->"); HashMap<Integer, String>map_2 = new HashMap<Integer, String>(); long start_map_2 = System.currentTimeMillis(); for(int i=MAX-1;i>=0;i--){ map_2.put(MAX-i-1, String.valueOf(MAX-i-1)); } long map_memory_2 = Runtime.getRuntime().totalMemory(); long end_map_2 = System.currentTimeMillis()-start_map_2; System.out.println("<---Map的插入时间--->"+end_map_2+"<---Map占用的内存--->"+map_memory_2); //执行后的结果: <------------- 数据量100000 Map 倒序插入---------------> <---Map的插入时间--->836<---Map占用的内存--->28598272
SparseArray倒序插入:
System.out.println("<------------- 数据量100000 散列程度小 SparseArray 倒序插入--------------->"); SparseArray<String>sparse_2 = new SparseArray<String>(); long start_sparse_2 = System.currentTimeMillis(); for(int i=MAX-1;i>=0;i--){ sparse_2.put(i, String.valueOf(MAX-i-1)); } long sparse_memory_2 = Runtime.getRuntime().totalMemory(); long end_sparse_2 = System.currentTimeMillis()-start_sparse_2; System.out.println("<---Sparse的插入时间--->"+end_sparse_2+"<---Sparse占用的内存--->"+sparse_memory_2); //执行后的结果 <------------- 数据量100000 SparseArray 倒序插入---------------> <---Sparse的插入时间--->20222<---Sparse占用的内存--->23281664
通过上面的运行结果,我们仍然可以看到,SparseArray与HashMap无论是怎样进行插入,数据量相同时,前者都要比后者要省下一部分内存,但是效率呢?我们可以看到,在倒序插入的时候,SparseArray的插入时间和HashMap的插入时间远远不是一个数量级.由于SparseArray每次在插入的时候都要使用二分查找判断是否有相同的值被插入.因此这种倒序的情况是SparseArray效率最差的时候.
这就是SparseArray插入函数的源码.每次的插入方式都需要调用二分查找.因此这样在倒序插入的时候会导致情况非常的糟糕,效率上绝对输给了HashMap学过数据结构的大家都知道.Map在插入的时候会对冲突因子做出相应的决策.有非常好的处理冲突的方式.不需要遍历每一个值.因此无论是倒序还是正序插入的效率取决于处理冲突的方式,因此插入时牺牲的时间基本是相同的.
通过插入.我们还是可以看出二者的差异的.
我们再来看一下查找首先是HashMap的查找.
System.out.println("<------------- 数据量100000 Map查找--------------->"); HashMap<Integer, String>map = new HashMap<Integer, String>(); for(int i=0;i<MAX;i++){ map.put(i, String.valueOf(i)); } long start_time =System.currentTimeMillis(); for(int i=0;i<MAX;i+=100){ map.get(i); } long end_time =System.currentTimeMillis()-start_time; System.out.println(end_time); //执行后的结果 <!---------查找的时间:175------------>
SparseArray的查找:
System.out.println("<------------- 数据量100000 SparseArray 查找--------------->"); SparseArray<String>sparse = new SparseArray<String>(); for(int i=0;i<10000;i++){ sparse.put(i, String.valueOf(i)); } long start_time =System.currentTimeMillis(); for(int i=0;i<MAX;i+=10){ sparse.get(i); } long end_time =System.currentTimeMillis()-start_time; System.out.println(end_time); //执行后的结果 <!-----------查找的时间:239---------------->
我这里也简单的对查找的效率进行了测试.对一个数据或者是几个数据的查询.二者的差异还是非常小的.当数据量是100000条.查100000条的效率还是Map要快一点.数据量为10000的时候.这就差异性就更小.但是Map的查找的效率确实还是赢了一筹.
其实在我看来.在保存<Integer,E>时使用SparseArray去替换HashMap的主要原因还是因为内存的关系.我们可以看到.保存的数据量无论是大还是小,Map所占用的内存始终是大于SparseArray的.数据量100000条时SparseArray要比HashMap要节约27%的内存.也就是以牺牲效率的代价去节约内存空间.我们知道Android对内存的使用是极为苛刻的.堆区允许使用的最大内存仅仅16M.很容易出现OOM现象的发生.因此在Android中内存的使用是非常的重要的.因此官方才推荐去使用SparseArray<E>去替换HashMap<Integer,E>.官方也确实声明这种差异性不会超过50%.所以牺牲了部分效率换来内存其实在Android中也算是一种很好的选择吧.