SparseArray源码分析

最新推荐文章于 2021-06-04 17:26:42 发布

置顶 Samlss

最新推荐文章于 2021-06-04 17:26:42 发布

阅读量386

点赞数 1

分类专栏： android 文章标签： android SparseArray

本文链接：https://blog.csdn.net/Samlss/article/details/89648110

版权

android 专栏收录该内容

24 篇文章 1 订阅

订阅专栏

SparseArray源码分析

SparseArray(稀疏数组)是什么？

类似于map，可以储存key-value键值对，与HashMap不同因为其key只能是整型int而且内部存储结构是数组（最新HashMap存储结构为红黑树+链表+数组）；为android的工具类，用于优化HashMap<Integer, V>这种情况。由于其内部使用数组来存储key和value，且数组内容可能大部分都并未使用，因此叫稀疏数组。
SparseArray的优势劣势？

与HashMap相对比，SparseArray的内存效率更高，因为它避免了自动装箱键，并且没有HashMap中额外的节点(链表节点，红黑树节点)内存开销。但是由于SparseArray将key放在一个数组结构中，且使用二分查找，因此其不适用于大数据量的储存。例如储存数百个数据，速度和HashMap相当，性能差异不明显，并且两者之间性能差异小于50%。相比于HashMap，SparseArray更节省内存，但是在大数据量的时候，插入和查找的效率都会比HashMap低。
SparseArray的应用场景？

适用于储存小容量数据，key必须为int型

下面分析源码：

类成员变量：

private static final Object DELETED = new Object();
private boolean mGarbage = false;

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

DELETED：用于标记已删除的key-value
mGarbage：用于标记是否需要回收被删除的数据
mKeys：用于储存key
mValues：用于储存values
mSize：当前包含非空元素(value)的条目(key-value)，未调用gc前，包括value为DELETED的情况，这里的gc并非为java中的System.gc()，而是SparseArray中的gc方法。

构造函数

public SparseArray() {
    this(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;
}

默认构造函数：调用带参构造函数，指定容量为10
带参(指定数组容量)构造函数：容量为空则赋值mKeys和mValues为长度为0的数组，否则创建最小长度为initialCapacity的Unpadded Object数组，再将key数组的大小指定为value数组的大小。

关于EmptyArray：

点我查看源码

//版本名称:  Oreo API Level:  26
public final class EmptyArray {
    private EmptyArray() {}

    public static final boolean[] BOOLEAN = new boolean[0];
    public static final byte[] BYTE = new byte[0];
    public static final char[] CHAR = new char[0];
    public static final double[] DOUBLE = new double[0];
    public static final float[] FLOAT = new float[0];
    public static final int[] INT = new int[0];
    public static final long[] LONG = new long[0];

    public static final Class<?>[] CLASS = new Class[0];
    public static final Object[] OBJECT = new Object[0];
    public static final String[] STRING = new String[0];
    public static final Throwable[] THROWABLE = new Throwable[0];
    public static final StackTraceElement[] STACK_TRACE_ELEMENT = new StackTraceElement[0];
    public static final java.lang.reflect.Type[] TYPE = new java.lang.reflect.Type[0];
    public static final java.lang.reflect.TypeVariable[] TYPE_VARIABLE =
        new java.lang.reflect.TypeVariable[0];
}

关于ArrayUtils.newUnpaddedObjectArray：

点我查看源码

// 版本名称:  Oreo API Level:  26
public static Object[] newUnpaddedObjectArray(int minLen) {
    return (Object[])VMRuntime.getRuntime().newUnpaddedArray(Object.class, minLen);
}

其中调用了VMRuntime.getRuntime().newUnpaddedArray来分配object数组内存，该方法字面意思为new一个un padded的数组，即new一个不填充的数组。返回一个至少为minLen长度的数组，但有可能会更大。增加的大小用于避免数组排列时填充的大小，填充量取决于组件类型和内存分配器实现。因为编译器会根据数组对齐，在申请obj内存时，往往会分配大于该obj的实际内存而保证自然对齐使CPU读写更加高效，但是这往往需要填充一些没有用到的空间，因此，为了不浪费这个空间，array变得更大了。

关于数据结构对齐可以看wiki描述：https://en.wikipedia.org/wiki/Data_structure_alignment

put

public void put(int key, E value) {
	int i = ContainerHelpers.binarySearch(mKeys, mSize, key); //二叉查找，可以看后面的方法解释

	if (i >= 0) {
		mValues[i] = value; //数组中存在该key，直接更新值
	} else {
		i = ~i;  //取到要插入的数组下标
	
         //如果要插入的下标小于mSize且被标志为已删除的话
         //重新将key赋值，value赋值
		if (i < mSize && mValues[i] == DELETED) {
			mKeys[i] = key;
			mValues[i] = value;
			return;
		}
         
         //如果标记为mBarbage且mSize大于或者等于key数组大小
		if (mGarbage && mSize >= mKeys.length) {
             //gc方法回收已删除的数据
			gc();

			//重新进行二叉搜索，因为索引可能已经发生变化了
			i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
		}
        
         //插入key
		mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);
         //插入value
		mValues = GrowingArrayUtils.insert(mValues, mSize, i, value);
         //mSize加1
		mSize++;
	}
}

首先通过二分查找是否在数组中存在该key，若找到，则返回对应的数组下标，否则，返回要插入的数组下标的负数
如果存在的话，直接将对应的value数组下标赋值
如果不存在的话，返回要插入的数组下标的负数，因此这里重新取反，拿到要插入数组下标的整数。再根据条件判断key是否为已删除数据，是否要进行数组压缩，最后插入key和value到各自数组中。

关于ContainerHelpers.binarySearch：

//该方法要求array必须为有序数组
//array：要查找的数组
//size：数组中有效大小，从下表0开始，到size-1为数组的有效范围
//value：要查找的值
static int binarySearch(int[] array, int size, int value) {
    //定义low低数组下标，用于数组中往上查找，最小为0
	int lo = 0; 
    
    //定义high高数组下标，用于数组中往下查找，最大为size-1
	int hi = size - 1; 

    //如果lo <= hi，则循环
	while (lo <= hi) {
         //取数组中间下标
         //右移1位即等同于除以2的1次方即除2，无符号右移，空位都以0补齐，与运算比除预算效率高
		final int mid = (lo + hi) >>> 1;  
        
         //取数组中间下标的值
		final int midVal = array[mid];

         //若中间值小于value，则将low赋值为mid+1，继续往上查找
		if (midVal < value) {
			lo = mid + 1;
            
         //若中间值大于value，则将high赋值为mid-1，继续往下查找
		} else if (midVal > value) {
			hi = mid - 1;
            
         //已找到，返回数组下标
		} else {
			return mid;  // value found
		}
	}
    //否则返回一个小于0的值，且该值还有另外一个含义：
    //要插入的位置下标，SparseArray拿到这个返回值后，便可知道要插入的下标
    //该值还有另外一个作用就是可以保证数组的有序性
	return ~lo;  // value not present
}

关于gc

该方法为SparseArray的回收方法，用于将删除的数据从mKeys数组和mValues数组中删除，并将剩下的数据往前移动

private void gc() {
	// Log.e("SparseArray", "gc start with " + mSize);

	int n = mSize; //当前数组有效大小，因为mkey大小和mValues大小相同，因此这里mSize是对两者而言的
	int o = 0; //数组中非null的数量，即有效数据数量，起始值为0
    
	int[] keys = mKeys;
	Object[] values = mValues;

	for (int i = 0; i < n; i++) {
		Object val = values[i];

         //不是被删除的元素
		if (val != DELETED) { 
             //若i 不等于 o的话
             //证明o为被删除的下标，因此这里需要将下标为o的key数组的值
             //赋值为下标为i的值，且将下标为o的value数组的值赋值为当前val
             //最后将已经移走的当前下标i对应的value数组的值置为null
             //但是这里可以看到，key[i]并没有置为0，因为不设置为0的话
             //不会影响二叉查找，因为后面mSize为非null数据数量
			if (i != o) {
				keys[o] = keys[i];
				values[o] = val;
				values[i] = null;
			}
            
             //有效数据+1
			o++;
		}
	}

	mGarbage = false; //gc后将回收标志置为false
	mSize = o; //将mSize赋值为数组中非null的数量

	// Log.e("SparseArray", "gc end with " + mSize);
}

关于GrowingArrayUtils.insert

点我查看源码

//array: 要插入的数组
//currentSize: 数组中的元素数量，小于或等于array.length
//index: 要插入的下标
//element: 要插入的元素
public static <T> T[] insert(T[] array, int currentSize, int index, T element) {
    //如果数组中的元素数量大于数组长度的话，抛出异常
	assert currentSize <= array.length;
    
    //如果在当前数组再插入一个元素，并且不超过数组的大小的话
	if (currentSize + 1 <= array.length) {
         //将原本数据从index开始，往后移动currentSize - index个数据
		System.arraycopy(array, index, array, index + 1, currentSize - index);
         //将index对应的值赋值为要插入的元素
		array[index] = element;
		return array;
	}

	@SuppressWarnings("unchecked")
    //否则需要重新创建数组，且将原本数组的内容赋值到新数组中
	T[] newArray = ArrayUtils.newUnpaddedArray((Class<T>)array.getClass().getComponentType(),
			growSize(currentSize));
	System.arraycopy(array, 0, newArray, 0, index);
	newArray[index] = element;
	System.arraycopy(array, index, newArray, index + 1, array.length - index);
	return newArray;
}

append

直接put一个key-value到数组中，针对key大于mKeys数组所有现有键的情况进行优化。

public void append(int key, E value) {
     //若当前mSize不为0且key小于mKeys数组中的最大值
	if (mSize != 0 && key <= mKeys[mSize - 1]) {
         //直接put
		put(key, value);
		return;
	}
    
     //mGarbage回收标志为true且mSize大于或等于mKeys数组长度
	if (mGarbage && mSize >= mKeys.length) {
         //调用gc方法
		gc();
	}
    
    
    //插入key
	mKeys = GrowingArrayUtils.append(mKeys, mSize, key);
    //插入value
	mValues = GrowingArrayUtils.append(mValues, mSize, value);
    
	mSize++;
}

setValueAt

按照给定的index替换value


public void setValueAt(int index, E value) {
    //mGarbage回收标志为true的话调用gc方法
	if (mGarbage) {
		gc();
	}
    
    //将对应index下表的值赋值为value
	mValues[index] = value;
}

get

//根据key获取value
public E get(int key) {
	return get(key, null);
}

//根据key获取value，若该key不存在或者已删除，返回valueIfKeyNotFound
public E get(int key, E valueIfKeyNotFound) {
     //首先进行二分查找 找到key的数组下表
	int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
    
     //i小于0代表mKeys数组中不包含该Key，或者该key-value已被删除
	if (i < 0 || mValues[i] == DELETED) {
		return valueIfKeyNotFound;
	} else {
		return (E) mValues[i];
	}
}

remove

//删除key对应的数据
public void remove(int key) {
	delete(key);
}

//删除key对应的数据
public void delete(int key) {
    //先通过二叉查找是否存在该key
	int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
    
    //i >= 0代表存在该key且i为其在mKeys数组中的下标
	if (i >= 0) {
         //且该key对应的value还没被删除
		if (mValues[i] != DELETED) {
             //将对应mValues数组下表的值置位DELETED已删除
			mValues[i] = DELETED;
             //将回收标志置为true，在调用size(), put(), append()等方法时需要
             //调用gc方法将被标记为已删除的数据，即对应的value值为DELETED
             //从数组移除，且将后面的没被删除的数据往前移动
			mGarbage = true;
		}
	}
}

//删除对应下表的数据
public void removeAt(int index) {
	if (mValues[index] != DELETED) {
		mValues[index] = DELETED;
         //将回收标志置为true
		mGarbage = true;
	}
}

//删除从对应下表开始，大小为size的数据
public void removeAtRange(int index, int size) {
	final int end = Math.min(mSize, index + size);
	for (int i = index; i < end; i++) {
		removeAt(i);
	}
}

查询

indexOfKey

根据key获取其在数组中的下表

public int indexOfKey(int key) {
     //mGarbage回收标志为true的话调用gc方法
	if (mGarbage) {
		gc();
	}
    
    //若数组中存在该key，则返回对应下表
    //否则返回一个负数
	return ContainerHelpers.binarySearch(mKeys, mSize, key);
}

indexOfValue

根据value获取其在数组中的下表

public int indexOfValue(E value) {
    //mGarbage回收标志为true的话调用gc方法
	if (mGarbage) {
		gc();
	}
    
    //遍历mValues数组，判断是否相等
	for (int i = 0; i < mSize; i++) {
		if (mValues[i] == value) { 
             //若相等，则返回i
			return i;
		}
	}
    
    //否则返回-1
	return -1;
}

keyAt

获取下表为index的key

public int keyAt(int index) {
     //mGarbage回收标志为true的话调用gc方法
	if (mGarbage) {
		gc();
	}

     //返回mKeys数组数据
	return mKeys[index];
}

valueAt

获取下表为index的value

public E valueAt(int index) {
     //mGarbage回收标志为true的话调用gc方法
	if (mGarbage) {
		gc();
	}

    //返回mValues/数组数据
	return (E) mValues[index];
}

Samlss

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录