SparseArray源码分析

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];
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值