ArrayMap源码分析

最新推荐文章于 2022-03-09 17:35:22 发布
最新推荐文章于 2022-03-09 17:35:22 发布
阅读量134 收藏
点赞数
分类专栏： 数据结构 文章标签： ArrayMap 数据结构 数组集合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011101777/article/details/100131027
版权
存储结构默认大小线程安全扩容机制删除策略
双数组0否n<4:4; n<8:8;n>=8:1.5n;直接删除，并带有部分内存收缩操作

成员变量

    static Object[] mBaseCache;//缓存的长度为4的key和value的内存，其结构下文会详细说明
    static int mBaseCacheSize;//缓存的个数，大小在10个以内
    static Object[] mTwiceBaseCache;//缓存的长度为8的key和value的内存
    static int mTwiceBaseCacheSize;//缓存的个数，大小在10个以内

    final boolean mIdentityHashCode;//生成hashcode的方法，mIdentityHashCode ? System.identityHashCode(key) : key.hashCode()System.identityHashCode
    int[] mHashes;//存储key的hash值，升序
    Object[] mArray;//存储key和value的值，key的下一个数据项就是该key对应的value
    int mSize;//当前集合存储的数据个数

创建集合

   public ArrayMap(int capacity) {
        this(capacity, false);
    }

    /** {@hide} */
    public ArrayMap(int capacity, boolean identityHashCode) {
        mIdentityHashCode = identityHashCode;
        if (capacity < 0) {
            mHashes = EMPTY_IMMUTABLE_INTS;
            mArray = EmptyArray.OBJECT;
        } else if (capacity == 0) {
            mHashes = EmptyArray.INT;
            mArray = EmptyArray.OBJECT;
        } else {
            allocArrays(capacity);
        }
        mSize = 0;
    }

可以看到，ArrayMap设置小于0的容量时，并不会直接报错，然后大于0时主要使用allocArrays去初始化集合

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--;
                    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--;
                    return;
                }
            }
        }

        mHashes = new int[size];
        mArray = new Object[size<<1];
    }

allocArrays方法主要分为3步：

  1. 如果之前设置了容量小于0，则不允许申请内存
  2. 如果当前申请的size为4或者8，而且当前对应缓存存在可用，则使用缓存
  3. 否则直接初始化新的数组，mHashes长度为size，mArray长度为2倍mHashes，其原因是因为mArray中存储的是key和value，而mHasher中存储的仅为key的hash值

关于缓存结构

缓存结构
在缓存结构上，mBaseCache和mTwiceBaseCache是一致的，只是在存在的数据的长度上不一样，如上图，长度为2的数int类型的数组，对应于mHashes，长度为4的是Object类型的数组，对应于mArray。可以看出Object数组中的第一项指向下一个缓存，第二项为当前缓存的存储hash值的int缓存数组

插入数据

@Override
    public V put(K key, V value) {
        final int osize = mSize;
        final int hash;
        int index;
        if (key == null) {
            hash = 0;
            index = indexOfNull();
        } else {
            hash = mIdentityHashCode ? System.identityHashCode(key) : 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 (osize >= mHashes.length) {
            final int n = osize >= (BASE_SIZE*2) ? (osize+(osize>>1))
                    : (osize >= 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 (CONCURRENT_MODIFICATION_EXCEPTIONS && osize != mSize) {
                throw new ConcurrentModificationException();
            }

            if (mHashes.length > 0) {
                if (DEBUG) Log.d(TAG, "put: copy 0-" + osize + " to 0");
                System.arraycopy(ohashes, 0, mHashes, 0, ohashes.length);
                System.arraycopy(oarray, 0, mArray, 0, oarray.length);
            }

            freeArrays(ohashes, oarray, osize);
        }

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

        if (CONCURRENT_MODIFICATION_EXCEPTIONS) {
            if (osize != mSize || index >= mHashes.length) {
                throw new ConcurrentModificationException();
            }
        }
        mHashes[index] = hash;
        mArray[index<<1] = key;
        mArray[(index<<1)+1] = value;
        mSize++;
        return null;
    }

插入操作分为如下步骤：

  1. 通过key和hash定位到该key在mHashes和mArray当中的下标。因为mHashes中到hash值是升序存储，这里采用了二分法查找，因为存在hash冲突，所以还得比较key是否相等，可以参照ArrayMap结构图。
  2. 如果找到下标（index>=0）,则覆盖原来到value，并返回该值
  3. 如果没找到（index<0），则～index为插入到期望下标，此时如果mHashes已满，则申请扩容，并释放或者缓存原来的内存。如果mHashes未满，则使用System的arraycopy方法移动数据，以为即将插入的数据腾出空间。
  4. 对应index上插入key和value，并更新size
    ArrayMap结构图
    这里关注下扩容细节，主要三个方面，扩容大小的计算、扩容内存申请和老数据迁移，老内存的处理；

final int n = osize >= (BASE_SIZE2) ? (osize+(osize>>1))
: (osize >= BASE_SIZE ? (BASE_SIZE2) : BASE_SIZE);

扩容大小的计算根据当前不同的size处理不一样：

  1. 如果osize>=8:则新的size为osize的3/2
  2. 如果osize<8 && osize >= 4：则新size为8
  3. 如果osize<4:则新size为4

扩若内存的申请使用allocArrays方法，该方法我们分析过，会优先尝试使用缓存，不存在缓存才申请对应内存，需要注意的是该方法会给mHashes和mArray重新赋值，而老数据的迁移则使用了System.arraycopy进行数据的拷贝。
而老内存的释放，则调用了freeArrays方法：

private static void freeArrays(final int[] hashes, final Object[] array, final int size) {
        if (hashes.length == (BASE_SIZE*2)) {
            synchronized (ArrayMap.class) {
                if (mTwiceBaseCacheSize < CACHE_SIZE) {
                    array[0] = mTwiceBaseCache;
                    array[1] = hashes;
                    for (int i=(size<<1)-1; i>=2; i--) {
                        array[i] = null;
                    }
                    mTwiceBaseCache = array;
                    mTwiceBaseCacheSize++;
                    if (DEBUG) Log.d(TAG, "Storing 2x cache " + array
                            + " now have " + mTwiceBaseCacheSize + " entries");
                }
            }
        } else if (hashes.length == BASE_SIZE) {
            synchronized (ArrayMap.class) {
                if (mBaseCacheSize < CACHE_SIZE) {
                    array[0] = mBaseCache;
                    array[1] = hashes;
                    for (int i=(size<<1)-1; i>=2; i--) {
                        array[i] = null;
                    }
                    mBaseCache = array;
                    mBaseCacheSize++;
                    if (DEBUG) Log.d(TAG, "Storing 1x cache " + array
                            + " now have " + mBaseCacheSize + " entries");
                }
            }
        }
    }

freeArrays方法是主要做的事情就是回收老内存，当老数据的长度满足缓存的条件（长度为4或者8）时，且当前缓存个数还未满（10），则将老数组中元素置为空，并将老数组缓存到对应的缓存中，注意这里是头部插入，也就是最后插入的缓存，会最先被使用。

删除元素

删除元素最后会调用到remove方法：

public V removeAt(int index) {
        final Object old = mArray[(index << 1) + 1];
        final int osize = mSize;
        final int nsize;
        if (osize <= 1) {
            freeArrays(mHashes, mArray, osize);
            mHashes = EmptyArray.INT;
            mArray = EmptyArray.OBJECT;
            nsize = 0;
        } else {
            nsize = osize - 1;
            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 = osize > (BASE_SIZE*2) ? (osize + (osize>>1)) : (BASE_SIZE*2);
                final int[] ohashes = mHashes;
                final Object[] oarray = mArray;
                allocArrays(n);

                if (CONCURRENT_MODIFICATION_EXCEPTIONS && osize != mSize) {
                    throw new ConcurrentModificationException();
                }

                if (index > 0) {
                    System.arraycopy(ohashes, 0, mHashes, 0, index);
                    System.arraycopy(oarray, 0, mArray, 0, index << 1);
                }
                if (index < nsize) {
                    System.arraycopy(ohashes, index + 1, mHashes, index, nsize - index);
                    System.arraycopy(oarray, (index + 1) << 1, mArray, index << 1,
                            (nsize - index) << 1);
                }
            } else {
                if (index < nsize) {
                    System.arraycopy(mHashes, index + 1, mHashes, index, nsize - index);
                    System.arraycopy(mArray, (index + 1) << 1, mArray, index << 1,
                            (nsize - index) << 1);
                }
                mArray[nsize << 1] = null;
                mArray[(nsize << 1) + 1] = null;
            }
        }
        if (CONCURRENT_MODIFICATION_EXCEPTIONS && osize != mSize) {
            throw new ConcurrentModificationException();
        }
        mSize = nsize;
        return (V)old;
    }

删除操作接收一个index，表示对应hash在mHashes数组中的下标，在remove方法中，首先通过(index << 1) + 1定位到对应的object数组下标，找到对应的value。接着判断是否只有一个元素，是则直接给mHashes和mArray赋值为EmptyArray，并释放内存。如果不是只有一个元素，则进行下列操作：

  1. 若当前容量大于8，且当前元素个数小于容量的三分之一，则触发内存收缩操作。收缩后的容量计算方式为：

final int n = osize > (BASE_SIZE2) ? (osize + (osize>>1)) : (BASE_SIZE2);

  1. 若不满足内存收缩条件，则直接调用System.arraycopy拷贝原数组中元素，覆盖index对应的值，并置空nsize对应的值，更新mSize；
三村阿明
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android ArrayMap源代码分析
01-04
分析源码之前先来介绍一下ArrayMap的存储结构，ArrayMap数据的存储不同于HashMap和SparseArray。 　Java提供了HashMap，但是HashMap对于手机端而言，对空间的利用太大，所以Android提供了SparseArray和ArrayMap。二者都是基于二分查找，所以数据量大的时候，最坏效率会比HashMap慢很多。因此建议数量在千以内比较合适。  一、SparseArray 　　SparseArray对应的key只能是int类型，它不会对key进行装箱操作。它使用了两个数组，一个保存key，一个保存value。 　　SparseArray使用二分查找来找到k
ArrayMap源码解析
u010257931的博客
07-07 1010
注意：mSize表示的是数组mHashes的大小，而mArray的大小为2*mSize。若key的hash在mHashes的位置索引为index，那么key在mArray中的位置索引keyIndex=index
android数据存放map_【Android源码研读】ArrayMap
weixin_39611769的博客
12-22 114
理解ArrayMap代码最好的方式就是图形化其内部原理。本文尝试用图形的方式表达其设计思想。首先ArrayMap中有2个相关的数组，mArray和mHashse，mArray存储key及value，mHashes中存入hash值。其有如下性质：- mArray总是mHashes的2倍；- 同一条数据，在mHashes中存储hash值，mArray中存储key和value；下标对应关系为，若该key...
ArrayMap与SparseArray源码分析
chewbee的专栏
06-10 1535
一ArrayMap 简介 源码分析 1 构造方法 2 添加元素 3 获取元素 4 移除元素 二SparseArray 简介 源码分析 1 构造方法 2 添加元素 3 获取元素 4 删除元素 5 其他方法 三总结 ArrayMap及SparseArray是android的系统API，是专门为移动设备而定制的。用于在一定情况下取代HashMap而达到节省内存的目的。本文将从源码的角度来分析ArrayMa
HashMap和ArrayMap实现原理的区别以及各自优势
分享+记录
06-13 1832
看了一下午的HashMap的实现原理，感觉很有必要记录下来，防止之后忘记。 一、首先是源码分析，讲一下HashMap。 1.HashMap结构 HashMap当中，存储最终数据的其实是一个HashMapEntry类型的数组：HashMapEntry[] table。 而HashMapEntry对象其实是属于一种单向链表结构。 这样最终其实是构造了一种二维的结构。 我们看一下Ha
SparseOrMap:尝试测试SparseArray和ArrayMap
05-17
SparseArray还是ArrayMap？ 实验 我创建了这个项目，以测试创建一个具有100,000个对象的SparseArray和ArrayMap需要花费多长时间。 我得到的结果（以毫秒为单位）： 根据文档， 和均不适用于可能包含大量项目的数据...
浅析php中array_map和array_walk的使用对比
10-21
给大家先是详细的介绍了array_map()和array_walk()的语法、参数以及注意事项，而后又给大家详细的介绍了其中的关键点，文中介绍的很详细，相信会对大家的理解和学习很有帮助，有需要的朋友们可以参考借鉴，感兴趣的...
Collections源码java-Java-Collections-Resize-Logic-Note:从源码角度分析Java中常用集合类的
05-19
从源码角度分析Java中常用集合类的扩容机制 从这一篇开始，会陆续通过笔记来整理和记录之前看过的各种Java集合相关的知识点，主要包括List和Map。今天这一篇主要整理一下集合扩容相关的知识，涉及到的集合框架有：...
深度解读ArrayMap优势与缺陷
Gityuan的博客
01-25 2494
ArrayMap在内存使用上较HashMap更有优势，在Android开发中广为使用的基础API，也是大家所推荐的方法，但你是否想过Google如此重要的基础类存在缺陷？...
arraymap android,深入剖析 Android中的 ArrayMap
weixin_39776239的博客
05-27 305
数据集合在任何一门编程语言中都是很重要的一部分，在 Android 开发中，我们会实用到ArrayList, LinkedList, HashMap等。其中HashMap是用来处理键值对需求的常用集合。 而Android中引入了一个新的集合，叫做ArrayMap，为键值对存储需求增加了一种选择。ArrayMap是什么一个通用的key-value映射数据结构相比HashMap会占用更少的内存空间an...
ArrayMap 源码解析
u011035026的博客
03-09 2939
1、简述 我们都知道 HashMap，它属于 java.util 包下，但是很多人可能对 ArrayMap 并不是很熟悉，通俗来说 ArrayMap 属于 android.util 包下，是用于 Android 平台某些情况替换 HashMap 的数据结构。 使用限定：minSdkVersion 必须大于等于 19（Android 4.4）。 2、归纳 实现了 Map 接口。 底层采用两个一维数组，第一个数组是整型数组，且有序，存储 key 对应的 hash 值，第二个数组存储 key 和 value
不再害怕面试问ArrayMap一文完全看懂Android ArrayMap源码解析
02-25 2064
作者：VIjolie 前言 ArrayMap是谷歌推出的在安卓等设备上用于替代HashMap的数据结构，和HashMap相比，具有更高的内存使用率，因此适合在Android等内存较为紧张的移动设备，下面结合源码分析ArrayMap实现原理，主要分为添加数据、查找数据、删除数据以及缓存四部分，注意本文基于api29。 构造函数 首先先来来康康ArrayMap的构造函数如下： /** {@hide} */ public ArrayMap(int capacity, boolean identityHashC.
ArrayMap 源码分析
FengZH的博客
12-19 244
文章目录概述主要属性构造方法putindexOfNull()indexOfremoveget参考 概述 ArrayMap 是 Android 的 API，它和 Java 的 HashMap 相比，虽然在查找效率上不如 HashMap（HashMap 查找的时间复杂度是 O(1), ArrayMap 查找的时间复杂度是 O(logn)），但是 ArrayMap 的空间消耗更小，它内部使用数组存储 h...
java.lang.UnsupportedOperationException解决方法!!!
热门推荐
lcd的博客
05-08 1万+
在项目中对List进行操作时报错java.lang.UnsupportedOperationException，后来发现操作的List是由数组转换而成的，通过看源码发现问题，并写测试程序如下。 代码块： public class ListTest { public static void main(String[] args) { String[] array =...
Android中HashMap内存优化之ArrayMap和SparseArray
TuGeLe的博客
11-24 1229
ArrayMap及SparseArray是android的系统API，是专门为移动设备而定制的。用于在一定情况下取代HashMap而达到节省内存的目的。 在Android开发中HashMap使用频率相当高，回顾一下HashMap的结构，其是以array存储链表的头结点，找到头结点后在进行遍历查找，如下图： 时间效率方面，利用hash算法，插入和查找等操作都很快，
异常：UnsupportedOperationException及解决办法
u010802778的博客
03-01 8944
最近在修改同事的代码的时候，报了一个UnsupportedOperationException异常，代码如下： List&lt;String&gt; ccEmail = Splitter.on(",").splitToList(templateDetail.getCcEmail()); String supplierCcEmail = venderMapper.selectCcEmailB...
【内存优化】ArrayMap源码解析
欢迎关注微信公众号：DroidMind
09-21 2469
一、为什么要使用ArrayMap ArrayMap是一个普通的键值映射的数据结构，这种数据结构比传统的HashMap有着更好的内存管理效率。传统HashMap非常的好用，但是它对内存的占用非常的大。为了解决HashMap更占内存的弊端，Android提供了内存效率更高的ArrayMap。二、ArrayMap的实现原理 它内部使用两个数组进行工作，其中一个数组记录key hash过后的顺序列表，另
面试必备：ArrayMap源码解析
zxt0601的博客
10-24 6033
概括的说，ArrayMap 实现了implements Map<K, V>接口，所以它也是一个关联数组、哈希表。存储以key->value 结构形式的数据。它也是线程不安全的，允许key为null,value为null。 它相比HashMap，空间效率更高。 它的内部实现是基于两个数组。 一个int[]数组，用于保存每个item的hashCode. 一个Object[]数组，保存key/value键值对。容量
ArrayMap源码注释
FearlessBear的博客
07-18 188
ArrayMap源码详解 本文的分析基于Android SDK 6.0源码进行，通过对ArrapMap的源码的分析，了解它的使用和特点。代码中保留了原有的英文注释，并增加了自己学习过程中添加的中文注释。 package android.util; import libcore.util.EmptyArray; import java.util.Collection; import java.util.Map; import java.util.Set; /** * ArrayMap is a gen
遍历ArrayMap
最新发布
09-02
arraymap和hashmap都是Java中常见的数据结构，都可以用于存储键值对。它们的主要区别在于底层实现方式。arraymap底层是基于数组实现的，可以按照插入顺序遍历元素，而hashmap底层是基于哈希表实现的，可以以常量时间O(1)的速度访问元素。在存储少量数据时，arraymap的性能比hashmap要好；而在存储大量数据时，hashmap则更适合。另外，相比于arraymap，hashmap更容易实现一些高级功能，如线程安全性和迭代器。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值