Android基础学习(二)

最近我在进行Android App的性能提升，在使用Android Studio的Code Inspect功能的过程中，发现系统提醒我进行如下操作：

系统提醒我把HashMap替换成相应的SparseIntArray和SparseArray。
之前我有对HashMap进行一个学习。Android为了方便开发者，特意在android.util这个包中提供了几个提高效率的工具类：例如SparseIntArray和SparseArray。
那么为什么在这里SparseIntArray和SparseArray更合适呢？我们就要看一下SparseIntArray和SparseArray的源代码了（理解直接加在代码里）。

SparseArray.java

/** * SparseArrays map integers to Objects.  Unlike a normal array of Objects, * there can be gaps in the indices（索引）.  It is intended to be more memory efficient * than using a HashMap to map Integers to Objects, both because it avoids * auto-boxing keys and its data structure doesn't rely on an extra entry object * for each mapping. * * <p>Note that this container keeps its mappings in an array data structure, * using a binary search to find keys.  The implementation is not intended to be appropriate for * data structures * that may contain large numbers of items.因为使用了二分法，所以可能对于包含了大量数据的数据结构来说不太合适。  It is generally slower than a traditional * HashMap, since lookups require a binary search and adds and removes require inserting * and deleting entries in the array.  For containers holding up to hundreds of items, * the performance difference is not significant, less than 50%.</p> * * <p>To help with performance, the container includes an optimization when removing * keys: instead of compacting its array immediately, it leaves the removed entry marked * as deleted.  The entry can then be re-used for the same key, or compacted later in * a single garbage collection step of all removed entries.  This garbage collection will * need to be performed at any time the array needs to be grown or the the map size or * entry values are retrieved.</p> * * <p>It is possible to iterate over the items in this container using * {@link #keyAt(int)} and {@link #valueAt(int)}. Iterating over the keys using * <code>keyAt(int)</code> with ascending values of the index will return the * keys in ascending order, or the values corresponding to the keys in ascending * order in the case of <code>valueAt(int)</code>.</p> */SparseArray这个工具类并不应该用于存储大量的数据。SparseArray的原理是二分查找法，也因此key的类型都是整型。public class SparseArray<E> implements Cloneable {    private static final Object DELETED = new Object();    private boolean mGarbage = false;    private int[] mKeys;//key所在的数组    private Object[] mValues;//值所在的数组    private int mSize;//当前实际存放的数量    /**     * Creates a new SparseArray containing no mappings.     */    public SparseArray() {        this(10);    }    /**     * 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;    }    @Override    @SuppressWarnings("unchecked")    public SparseArray<E> clone() {        SparseArray<E> clone = null;        try {            clone = (SparseArray<E>) super.clone();            clone.mKeys = mKeys.clone();            clone.mValues = mValues.clone();        } catch (CloneNotSupportedException cnse) {            /* ignore */        }        return clone;    }    /**     * 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")    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];//查找到相应的值        }    }    /**     * Removes the mapping from the specified key, if there was any.     */    public void delete(int key) {    //使用了系统的二分查找法        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);        if (i >= 0) {            if (mValues[i] != DELETED) {                mValues[i] = DELETED;                mGarbage = true;            }        }    }    /**     * @hide     * Removes the mapping from the specified key, if there was any, returning the old value.     */    public E removeReturnOld(int key) {        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);        if (i >= 0) {            if (mValues[i] != DELETED) {                final E old = (E) mValues[i];                mValues[i] = DELETED;                mGarbage = true;                return old;            }        }        return null;    }    /**     * Alias for {@link #delete(int)}.     */    public void remove(int key) {        delete(key);    }    /**     * Removes the mapping at the specified index.     *     * <p>For indices outside of the range <code>0...size()-1</code>,     * the behavior is undefined.</p>     */    public void removeAt(int index) {        if (mValues[index] != DELETED) {            mValues[index] = DELETED;            mGarbage = true;        }    }    /**     * Remove a range of mappings as a batch.     *     * @param index Index to begin at     * @param size Number of mappings to remove     *     * <p>For indices outside of the range <code>0...size()-1</code>,     * the behavior is undefined.</p>     */    public void removeAtRange(int index, int size) {        final int end = Math.min(mSize, index + size);        for (int i = index; i < end; i++) {            removeAt(i);        }    }    当gc()被调用时，真正删除元素。    private void gc() {        // Log.e("SparseArray", "gc start with " + mSize);        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) {//i和o如果相等的话，意味着之前没有遍历到被删除的元素。                    keys[o] = keys[i];                    values[o] = val;                    values[i] = null;                }                o++;            }        }        mGarbage = false;//判断是否触发gc的变量        mSize = o;        // Log.e("SparseArray", "gc end with " + mSize);    }    /**     * Adds a mapping from the specified key to the specified value,     * replacing the previous mapping from the specified key if there     * was one.     */     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) {// 如果索引小于当前已经存放的长度，并且这个位置上的值为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++;        }    }    /**     * Returns the number of key-value mappings that this SparseArray     * currently stores.     */    public int size() {        if (mGarbage) {            gc();        }        return mSize;    }    /**     * Given an index in the range <code>0...size()-1</code>, returns     * the key from the <code>index</code>th key-value mapping that this     * SparseArray stores.     *     * <p>The keys corresponding to indices in ascending order are guaranteed to     * be in ascending order, e.g., <code>keyAt(0)</code> will return the     * smallest key and <code>keyAt(size()-1)</code> will return the largest     * key.</p>     *     * <p>For indices outside of the range <code>0...size()-1</code>,     * the behavior is undefined.</p>     */     获取键值    public int keyAt(int index) {        if (mGarbage) {            gc();        }        return mKeys[index];    }    /**     * Given an index in the range <code>0...size()-1</code>, returns     * the value from the <code>index</code>th key-value mapping that this     * SparseArray stores.     *     * <p>The values corresponding to indices in ascending order are guaranteed     * to be associated with keys in ascending order, e.g.,     * <code>valueAt(0)</code> will return the value associated with the     * smallest key and <code>valueAt(size()-1)</code> will return the value     * associated with the largest key.</p>     *     * <p>For indices outside of the range <code>0...size()-1</code>,     * the behavior is undefined.</p>     */     获取元素的值    @SuppressWarnings("unchecked")    public E valueAt(int index) {        if (mGarbage) {            gc();        }        return (E) mValues[index];    }    /**     * Given an index in the range <code>0...size()-1</code>, sets a new     * value for the <code>index</code>th key-value mapping that this     * SparseArray stores.     *     * <p>For indices outside of the range <code>0...size()-1</code>, the behavior is undefined.</p>     */     //更新某个key的值     public void setValueAt(int index, E value) {        if (mGarbage) {            gc();        }        mValues[index] = value;    }    /**     * Returns the index for which {@link #keyAt} would return the     * specified key, or a negative number if the specified     * key is not mapped.     */     用key值去找索引    public int indexOfKey(int key) {        if (mGarbage) {            gc();        }        return ContainerHelpers.binarySearch(mKeys, mSize, key);    }    /**     * Returns an index for which {@link #valueAt} would return the     * specified key, or a negative number if no keys map to the     * specified value.     * <p>Beware that this is a linear search, unlike lookups by key,     * and that multiple keys can map to the same value and this will     * find only one of them.     * <p>Note also that unlike most collections' {@code indexOf} methods,     * this method compares values using {@code ==} rather than {@code equals}.     */     用value去找索引    public int indexOfValue(E value) {        if (mGarbage) {            gc();        }        for (int i = 0; i < mSize; i++) {            if (mValues[i] == value) {                return i;            }        }        return -1;    }    /**     * Returns an index for which {@link #valueAt} would return the     * specified key, or a negative number if no keys map to the     * specified value.     * <p>Beware that this is a linear search, unlike lookups by key,     * and that multiple keys can map to the same value and this will     * find only one of them.     * <p>Note also that this method uses {@code equals} unlike {@code indexOfValue}.     * @hide     */     用value去找索引，但是使用的是equals。Java中equals和==的区别：java中的数据类型，可分为两类： 1.基本数据类型：byte,short,char,int,long,float,double,boolean   他们之间的比较，应用双等号（==）,比较的是他们的值。 2.复合数据类型(类)   当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。 JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地 址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。    public int indexOfValueByValue(E value) {        if (mGarbage) {            gc();        }        for (int i = 0; i < mSize; i++) {            if (value == null) {                if (mValues[i] == null) {                    return i;                }            } else {                if (value.equals(mValues[i])) {                    return i;                }            }        }        return -1;    }    /**     * Removes all key-value mappings from this SparseArray.     */     清空数组    public void clear() {        int n = mSize;        Object[] values = mValues;        for (int i = 0; i < n; i++) {            values[i] = null;        }        mSize = 0;        mGarbage = false;    }    /**     * 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++;    }    /**     * {@inheritDoc}     *     * <p>This implementation composes a string by iterating over its mappings. If     * this map contains itself as a value, the string "(this Map)"     * will appear in its place.     */     重载了toString方法：    @Override    public String toString() {        if (size() <= 0) {            return "{}";        }        StringBuilder buffer = new StringBuilder(mSize * 28);        buffer.append('{');        for (int i=0; i<mSize; i++) {            if (i > 0) {                buffer.append(", ");            }            int key = keyAt(i);            buffer.append(key);            buffer.append('=');            Object value = valueAt(i);            if (value != this) {                buffer.append(value);            } else {                buffer.append("(this Map)");            }        }        buffer.append('}');        return buffer.toString();    }}

总结

（1）当存储大量数据的时候，优先选择HashMap。
（2）如果只有几百个，用哪个区别不大。
（3）如果数量不多，优先选择SparseArray。
（4）parseIntArray只能存储integer类型的值。(其余基本原理和SparseArray类似)

也就是说，为了在实际工作中最合理的选用数据结构，深入的了解每种数据结构的实现原理是很有必要的，这样可以更好的理解和比较不同数据结构之间的优缺点，比死记概念要好。我们可以根据不同的使用场景去决定使用哪些数据结构，而不是僵硬地在任何地方都只使用一种数据结构。

http://blog.csdn.net/stzy00/article/details/45035301
https://developer.android.com/reference/android/util/SparseIntArray.html
http://extremej.itscoder.com/sparsearray_source_analyse/