HashMap、ArrayMap、SparseArray分析比较

最新推荐文章于 2024-08-26 23:15:58 发布
最新推荐文章于 2024-08-26 23:15:58 发布
阅读量251 收藏
点赞数
分类专栏： JAVA

HashMap、ArrayMap、SparseArray分析比较

   

一、原理分析 
1、HashMap分析 
HashMap是基于hash表非同步map实现，key和value都可以为null。其hash表实现方式是”拉链法”，可理解为链表的数组，如下图所示： 
这里写图片描述 
HashMap部分源码如下：

/**
 * The hash table. If this hash map contains a mapping    for null, it is
 * not represented this hash table.
 */
 transient HashMapEntry<K, V>[] table;
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
/**
 * Maps the specified key to the specified value.
 *
 * @param key
 *            the key.
 * @param value
 *            the value.
 * @return the value of any previous mapping with the specified key or
 *         {@code null} if there was no such mapping.
 */
@Override public V put(K key, V value) {
    if (key == null) {
        return putValueForNullKey(value);
    }

    int hash = Collections.secondaryHash(key);
    HashMapEntry<K, V>[] tab = table;
    int index = hash & (tab.length - 1);
    for (HashMapEntry<K, V> e = tab[index]; e != null; e = e.next) {
        if (e.hash == hash && key.equals(e.key)) {
            preModify(e);
            V oldValue = e.value;
            e.value = value;
            return oldValue;
        }
    }

    // No entry for (non-null) key is present; create one
    modCount++;
    if (size++ > threshold) {
        tab = doubleCapacity();
        index = hash & (tab.length - 1);
    }
    addNewEntry(key, value, hash, index);
    return null;
}

/**
 * Returns the value of the mapping with the specified key.
 *
 * @param key
 *            the key.
 * @return the value of the mapping with the specified key, or {@code null}
 *         if no mapping for the specified key is found.
 */
public V get(Object key) {
    if (key == null) {
        HashMapEntry<K, V> e = entryForNullKey;
        return e == null ? null : e.value;
    }

    int hash = Collections.secondaryHash(key);
    HashMapEntry<K, V>[] tab = table;
    for (HashMapEntry<K, V> e = tab[hash & (tab.length - 1)];
         e != null; e = e.next) {
        K eKey = e.key;
        if (eKey == key || (e.hash == hash && key.equals(eKey))) {
            return e.value;
        }
    }
    return null;
}

/**
 * Creates a new entry for the given key, value, hash, and index and
 * inserts it into the hash table. This method is called by put
 * (and indirectly, putAll), and overridden by LinkedHashMap. The hash
 * must incorporate the secondary hash function.
 */
void addNewEntry(K key, V value, int hash, int index) {
    table[index] = new HashMapEntry<K, V>(key, value, hash, table[index]);
}
   
   
  • 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
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
static class HashMapEntry<K, V> implements Map.Entry<K, V> {
    final K key;
    V value;
    final int hash;
    HashMapEntry<K, V> next;

    HashMapEntry(K key, V value, int hash, HashMapEntry<K, V> next) {
        this.key = key;
        this.value = value;
        this.hash = hash;
        this.next = next;
    }
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

HashMap的HashMapEntry

/**
 * Doubles the capacity of the hash table. Existing entries are placed in
 * the correct bucket on the enlarged table. If the current capacity is,
 * MAXIMUM_CAPACITY, this method is a no-op. Returns the table, which
 * will be new unless we were already at MAXIMUM_CAPACITY.
 */
private HashMapEntry<K, V>[] doubleCapacity() {
    HashMapEntry<K, V>[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
        return oldTable;
    }
    int newCapacity = oldCapacity * 2;
    HashMapEntry<K, V>[] newTable = makeTable(newCapacity);
    if (size == 0) {
        return newTable;
    }

    for (int j = 0; j < oldCapacity; j++) {
        /*
         * Rehash the bucket using the minimum number of field writes.
         * This is the most subtle and delicate code in the class.
         */
        HashMapEntry<K, V> e = oldTable[j];
        if (e == null) {
            continue;
        }
        int highBit = e.hash & oldCapacity;
        HashMapEntry<K, V> broken = null;
        newTable[j | highBit] = e;
        for (HashMapEntry<K, V> n = e.next; n != null; e = n, n = n.next) {
            int nextHighBit = n.hash & oldCapacity;
            if (nextHighBit != highBit) {
                if (broken == null)
                    newTable[j | nextHighBit] = n;
                else
                    broken.next = n;
                broken = e;
                highBit = nextHighBit;
            }
        }
        if (broken != null)
            broken.next = null;
    }
    return newTable;
}

/**
 * Allocate a table of the given capacity and set the threshold accordingly.
 * @param newCapacity must be a power of two
 */
private HashMapEntry<K, V>[] makeTable(int newCapacity) {
    @SuppressWarnings("unchecked") HashMapEntry<K, V>[] newTable
            = (HashMapEntry<K, V>[]) new HashMapEntry[newCapacity];
    table = newTable;
    threshold = (newCapacity >> 1) + (newCapacity >> 2); // 3/4 capacity
    return newTable;
}
   
   
  • 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
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58

扩容时执行makeTable方法，new一个原来两倍大小的HashMapEntry数据，并替换原table。

2、ArrayMap分析 
android.util.ArrayMap存储结构是由int[] mHashes和Object[] mArray两个数据组成，mHashes保存key的hashCode，mArray以键值对形式保存key和value。 
ArrayMap取数据时通过二分法查找index，获取相应value。 
ArrayMap在remove和clear后，会重新收缩数据，节约空间，但会降低执行效率。ArrayMap是牺牲了时间换取空间。官方给出的说明如下：

Note that this 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%.
   
   
  • 1

根据官方描述，由于查找方式采用的是二分法，并且当你删除或者添加数据时，会对空间重新调整，ArrayMap不太适合数据量比较大的场景。 
部分源码如下： 
put:

/**
 * Add a new value to the array map.
 * @param key The key under which to store the value.  If
 * this key already exists in the array, its value will be replaced.
 * @param value The value to store for the given key.
 * @return Returns the old value that was stored for the given key, or null if there
 * was no such key.
 */
@Override
public V put(K key, V value) {
    final int hash;
    int index;
    if (key == null) {
        hash = 0;
        index = indexOfNull();
    } else {
        hash = key.hashCode();
        index = indexOf(key, hash);
    }
    if (index >= 0) {
        index = (index<<1) + 1;
        final V old = (V)mArray[index];
        mArray[index] = value;
        return old;
    }

    index = ~index;
    // 容量不够
    if (mSize >= mHashes.length) {
        final int n = mSize >= (BASE_SIZE*2) ? (mSize+(mSize>>1))
                : (mSize >= BASE_SIZE ? (BASE_SIZE*2) : BASE_SIZE);

        if (DEBUG) Log.d(TAG, "put: grow from " + mHashes.length + " to " + n);

        final int[] ohashes = mHashes;
        final Object[] oarray = mArray;
        // 分配新容器
        allocArrays(n);

        if (mHashes.length > 0) {
            if (DEBUG) Log.d(TAG, "put: copy 0-" + mSize + " to 0");
            // copy方式存入新容器
            System.arraycopy(ohashes, 0, mHashes, 0, ohashes.length);
            System.arraycopy(oarray, 0, mArray, 0, oarray.length);
        }

        freeArrays(ohashes, oarray, mSize);
    }

    if (index < mSize) {
        if (DEBUG) Log.d(TAG, "put: move " + index + "-" + (mSize-index)
                + " to " + (index+1));
        System.arraycopy(mHashes, index, mHashes, index + 1, mSize - index);
        System.arraycopy(mArray, index << 1, mArray, (index + 1) << 1, (mSize - index) << 1);
    }

    mHashes[index] = hash;
    mArray[index<<1] = key;
    mArray[(index<<1)+1] = value;
    mSize++;
    return null;
}

private void allocArrays(final int size) {
    if (mHashes == EMPTY_IMMUTABLE_INTS) {
        throw new UnsupportedOperationException("ArrayMap is immutable");
    }
    if (size == (BASE_SIZE*2)) {
        synchronized (ArrayMap.class) {
            if (mTwiceBaseCache != null) {
                final Object[] array = mTwiceBaseCache;
                mArray = array;
                mTwiceBaseCache = (Object[])array[0];
                mHashes = (int[])array[1];
                array[0] = array[1] = null;
                mTwiceBaseCacheSize--;
                if (DEBUG) Log.d(TAG, "Retrieving 2x cache " + mHashes
                        + " now have " + mTwiceBaseCacheSize + " entries");
                return;
            }
        }
    } else if (size == BASE_SIZE) {
        synchronized (ArrayMap.class) {
            if (mBaseCache != null) {
                final Object[] array = mBaseCache;
                mArray = array;
                mBaseCache = (Object[])array[0];
                mHashes = (int[])array[1];
                array[0] = array[1] = null;
                mBaseCacheSize--;
                if (DEBUG) Log.d(TAG, "Retrieving 1x cache " + mHashes
                        + " now have " + mBaseCacheSize + " entries");
                return;
            }
        }
    }

    mHashes = new int[size];
    mArray = new Object[size<<1];
}
   
   
  • 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
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100

remove:

/**
 * Remove the key/value mapping at the given index.
 * @param index The desired index, must be between 0 and {@link #size()}-1.
 * @return Returns the value that was stored at this index.
 */
public V removeAt(int index) {
    final Object old = mArray[(index << 1) + 1];
    if (mSize <= 1) {
        // Now empty.
        if (DEBUG) Log.d(TAG, "remove: shrink from " + mHashes.length + " to 0");
        freeArrays(mHashes, mArray, mSize);
        mHashes = EmptyArray.INT;
        mArray = EmptyArray.OBJECT;
        mSize = 0;
    } else {
        if (mHashes.length > (BASE_SIZE*2) && mSize < mHashes.length/3) {
            // Shrunk enough to reduce size of arrays.  We don't allow it to
            // shrink smaller than (BASE_SIZE*2) to avoid flapping between
            // that and BASE_SIZE.
            final int n = mSize > (BASE_SIZE*2) ? (mSize + (mSize>>1)) : (BASE_SIZE*2);

            if (DEBUG) Log.d(TAG, "remove: shrink from " + mHashes.length + " to " + n);

            final int[] ohashes = mHashes;
            final Object[] oarray = mArray;
            allocArrays(n);

            mSize--;
            if (index > 0) {
                if (DEBUG) Log.d(TAG, "remove: copy from 0-" + index + " to 0");
                System.arraycopy(ohashes, 0, mHashes, 0, index);
                System.arraycopy(oarray, 0, mArray, 0, index << 1);
            }
            if (index < mSize) {
                if (DEBUG) Log.d(TAG, "remove: copy from " + (index+1) + "-" + mSize
                        + " to " + index);
                System.arraycopy(ohashes, index + 1, mHashes, index, mSize - index);
                System.arraycopy(oarray, (index + 1) << 1, mArray, index << 1,
                        (mSize - index) << 1);
            }
        } else {
            mSize--;
            if (index < mSize) {
                if (DEBUG) Log.d(TAG, "remove: move " + (index+1) + "-" + mSize
                        + " to " + index);
                System.arraycopy(mHashes, index + 1, mHashes, index, mSize - index);
                System.arraycopy(mArray, (index + 1) << 1, mArray, index << 1,
                        (mSize - index) << 1);
            }
            mArray[mSize << 1] = null;
            mArray[(mSize << 1) + 1] = null;
        }
    }
    return (V)old;
}
   
   
  • 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
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55

get:

@Override
public V get(Object key) {
    final int index = indexOfKey(key);
    return index >= 0 ? (V)mArray[(index<<1)+1] : null;
}

public int indexOfKey(Object key) {
    return key == null ? indexOfNull() : indexOf(key, key.hashCode());
}

int indexOf(Object key, int hash) {
    final int N = mSize;

    // Important fast case: if nothing is in here, nothing to look for.
    if (N == 0) {
        return ~0;
    }

    // 二分法查找
    int index = ContainerHelpers.binarySearch(mHashes, N, hash);

    // If the hash code wasn't found, then we have no entry for this key.
    if (index < 0) {
        return index;
    }

    // If the key at the returned index matches, that's what we want.
    if (key.equals(mArray[index<<1])) {
        return index;
    }

    // Search for a matching key after the index.
    int end;
    for (end = index + 1; end < N && mHashes[end] == hash; end++) {
        if (key.equals(mArray[end << 1])) return end;
    }

    // Search for a matching key before the index.
    for (int i = index - 1; i >= 0 && mHashes[i] == hash; i--) {
        if (key.equals(mArray[i << 1])) return i;
    }

    // Key not found -- return negative value indicating where a
    // new entry for this key should go.  We use the end of the
    // hash chain to reduce the number of array entries that will
    // need to be copied when inserting.
    return ~end;
}
   
   
  • 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
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

3、SparseArray分析 
SparseArray解析 
这篇文章中已做了分析。

二、比较 
HashMap、ArrayMap、SparseArray比较如下：

类 cpu 内存 适用场景
HashMap 增、删、查找速度较快 双倍扩容、不做空间整理，内存使用效率低 数据量较大或内存空间相对宽裕
ArrayMap 增、删、查速度较慢 size大于8扩容时，只增大当前数组大小的一半，做空间收缩整理 数据量小于1000时，速度相对差别不大，可替代HashMap
SparseArray 增、查速度较慢，由于延迟删除机制，删速度比ArrayMap快，比HashMap慢 矩阵压缩，大大减少了存储空间，节约内存 避免了key的自动装箱，空间压缩等机制，使得其在key是Integer、Long，且数据量较小场景下性能最优

本文源码均来自Android api 21 
参考文章： 
http://zha-zi.iteye.com/blog/1124484

不服老的码农
关注
专栏目录
Android 集合类HashMap、SparseArray 、ArrayMap的使用特点和使用场景
谢国荣的博客
09-20 472
Android 数据结构HashMap、SparseArray 、ArrayMap的使用特点和使用场景 一、
HashMap与ArrayMap(和SparseArray)的比较与选择
hohoho get it up
12-26 3802
HashMap和ArrayMap的实现分析 SparseArray实现分析 比较和选择
HashMap & ArrayMap & SparseArray
最新发布
qq_15915161的博客
08-26 608
数据结构|1.8之前是数组+单链表，1,8之后再加红黑树（链表长度大于8变树，树长度减少到6时变回单链表）|两个数组，一个数组存key的hash值（从小到大排序），一个存key和value|两个数组，一个存key（从小到大排序），一个存value|+ 到注释7 8会真正插入进去，如果index不在队尾，先把index处以后的数据都往后移一位，再在mHashes数组的index处插入key的hash值，mArray的2 * index处插入key，2*index+1处插入value。
SparseArray 和 HashMap区别
HelloWorld搬运工
06-23 1595
相同点： HashMap和SparseArray，都是用来存储Key-value类型的数据。 于是同样的需要面对几个问题，hash值的计算、扩容、hash冲突、装载率过低 不同点： 数据结构方面：hashmap用的是链表。sparsearray用的是双数组。性能方面：hashmap是默认16个长度，会自动装箱。如果key是int 的话，hashmap要先封装成Interger。sparseArray的话就就会直接转成int。所以spaseArray用的限制是key是int。数据量小于1k。如果ke
ArrayMap和HashMap区别
热门推荐
醉离歌醉的专栏
09-03 1万+
一：HashMap HashMap内部是使用一个默认容量为16的数组来存储数据的，而数组中每一个元素却又是一个链表的头结点，所以，更准确的来说，HashMap内部存储结构是使用哈希表的拉链结构（数组+链表），这种存储数据的方法叫做拉链法 。如图：  且每一个结点都是Entry类型，那么Entry是什么呢？我们来看看HashMap中Entry的属性：
HashMap,ArrayMap,SparseArray 源码角度分析,Android中的数据结构你该如何去选择？
m0_66264630的博客
01-19 598
table = newTab; 可以看到当我们的table数组存储的节点值大于threshold时,会按我们的当前数组大小的两倍生成一个新的数组，并把旧数组上的数据复制到新数组上这就是我们的HashMap扩容。伴随着一个新数组的生成和数组数据的copy，会有一定性能上的损耗。如果我们在使用HashMap的是能够明确HashMap能够一开始就清楚的知道HashMap存储的键值对个数，我建议我们使用HashMap的另一个构造方法。 public HashMap(int initialCapacity) { th
HashMap和ArrayMap实现原理的区别以及各自优势
qq_28845393的博客
02-18 1524
一、ArrayMap的构成原理 1、arrayMap的存储结构。 ArrayMap是一个&lt;key,value&gt;映射的数据结构，它设计上更多的是考虑内存的优化，内部是使用两个数组进行数据存储，一个数组记录key的hash值，另外一个数组记录Value值，它和SparseArray一样，也会对key使用二分法进行从小到大排序，在添加、删除、查找数据的时候都是先使用二分查找法得到相应的i...
ArrayMap跟HashMap区别
qq_34368542的博客
06-08 945
Hash碰撞的解决方式 提起存储键值对,首先想到的是Map集合,但是对于hash算法导致的hash碰撞,一般有两种解决方式: **链表法跟开放地址法,**对于Android应用开发来说,正好对应着HashMap跟ArrayMap的解决方式 ArrayMap: 开放地址法 笔者在使用Retrofit请求网络时由于需要将数据封装成map集合发送给后端,但是一般都是提交数据量很小的内容,因此使用ArrayMap替换HashMap已节约内存空间.这里通过源码分析两者之间的差别 首先查看构造函数 pub
内存优化之ArrayMap、SparseArray、SparseIntArray
1
08-31 328
作者：众小成多积小致巨 1、前言 这几个数据结构呢，都是Android这家伙搞出来；为啥呢，打的旗号是节约内存，系统的很多地方都有他们的身影;为了追随google的脚步，也为了扩展自己对于数据结构的理解，我们有必要学习它； 这里先大致说下，ArrayMap是一个map，是为了解决HashMap存储数据浪费空间情况；SparseArray是数组，为稀疏数据准备的；SparseXXXArray,也是数组，也为稀疏数据准备，xxx是基本数据类型，这样使用时不存在自动拆装箱操作（就是基本类型和相对应类之间的自动.
SparseArray与HashMap的区别
ly969434341的专栏
12-04 668
参考 （1）SparseArray： https://developer.android.com/reference/android/util/SparseArray （2）Android内存优化（使用SparseArray和ArrayMap代替HashMap） https://blog.csdn.net/u010687392/article/details/47809295 方案 ...
ArrayMap和HashMap的对比
qq_38366111的博客
03-17 669
内存占用：ArrayMap在存储少量数据时，相对于HashMap来说，占用的内存更少。查找效率：HashMap在查找和插入操作时，由于使用了哈希表，所以查找效率更高，时间复杂度为 O(1)。综上所述，ArrayMap适用于存储少量数据并且需要较低内存占用的场景，而HashMap适用于存储大量数据并且需要高效的查找操作的场景。数据顺序：HashMap不保证元素的顺序，而ArrayMap是按照插入顺序来存储元素的。实现方式：ArrayMap是基于数组实现的，HashMap基于哈希表实现的。
HashMap和ArrayMap的区别
yshh的博客
09-09 537
那HashMap和ArrayMap到底不同在哪呢，主要有以下几个方面：1、存储方式不同HashMap内部有一个HashMapEntry[java] view plaincopy @Override public V put(K key, V value) { if (key == null) { return putValueForNullKey(val
SparseArray与HashMap对比
perfectnihil的博客
06-08 704
1.SparseArray适用于key为int的场合，HashMap则使用于各种场合 2.SparseArray的内存占用较HashMap少 3.SparseArray性能和HashMap比并没有优势 SparseArray只有一个优势，省内存。。 参考： https://www.cnblogs.com/RGogoing/p/5095168.html https://blo...
HashMap和ArrayMap对比
流水mpc
06-08 1243
HashMap和ArrayMap各自的优势 1.查找效率: HashMap因为其根据hashcode的值直接算出index,所以其查找效率是随着数组长度增大而增加的。 ArrayMap使用的是二分法查找,所以当数组长度每增加一倍时,就需要多进行一次判断,效率下降。 所以对于Map数量比较大的情况下,推荐使用 2.扩容数量: HashMap初始值16个长度,每次扩容的时候,直接申请双倍的数组空间。 ArrayMap每次扩容的时候,如果size长度大于8时申请size*1.5个长度,大于4小于8时申请8个,小于
HashMap源码解读数据结构和. ArrayMap,SparseArray，TreeMap的区别
宋锦仑的博客
03-14 532
HashMap 1HashMap构造方法参数： initialCapacity为HashMap的初始容量默认为16。 loadFactor为加载因子默认为0.75，加载因子越大对空间利用越多查找速度慢。 1底层数据结构：在JDK 1.6和1.7采用 位桶+链表实现，同一个hash值的键...
HashMap和ArrayMap SparseArray
emmmsuperdan的博客
04-01 382
ArrayMap结构: 存放Entry键值对的数组结构； 而hashmap是数组+链表结构； arraymap和hashmap区别: 查找效率:hashmap通过hashcode计算的index直接拿到值；而arraymap是通过二分法查找拿到值； 因此数据量大的时候用hashmap； 构造源码: public class ArrayMap<K, V> extends AbstractMap<K, V> implements Map<K, V&...
SparseArray和ArrayMap代替HashMap
几度清浅的专栏
03-30 590
1、HashMap HashMap内部存储结构是使用哈希表的拉链结构（数组+链表），这种存储数据的方法叫做拉链法。 HashMap中默认的存储大小就是一个容量为16的数组，所以当我们创建出一个HashMap对象时，即使里面没有任何元素，也要分别一块内存空间 给它，而且，我们再不断的向HashMap里put数据时，当达到一定的容量限制时，HashMap的空间将会扩大，而且扩大后新的空间一定
3、 hashmap 工作原理是什么?与 sparsearray 、 arraymap 有什么差异?
10-27
HashMap 是一种用于存储键值对的数据结构。...另外，HashMap 支持 null 键和 null 值的存储，而 SparseArray 和 ArrayMap 不允许存储 null 键，只允许存储 null 值。因此，在对 null 键的需求较多时应选择 HashMap。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值