Android特有的数据结构

3 阅读6分钟

问题:

请详细列出 Android 平台中独有或常用的数据结构(例如 SparseArray、ArrayMap、LongSparseArray 等),并分别说明:

  1. 数据结构的主要功能和使用场景。

  2. 相比标准 Java 数据结构(如 HashMap、ArrayList)的优势或特殊优化。

  3. 在性能、内存占用、线程安全等方面的特点。

  4. 适用与不适用的场景示例。

请使用结构化的列表或表格进行说明,并提供简洁示例代码。

主要分三类:

  • Sparse 系列(键为 int / long / boolean 的稀疏映射)

  • Array 系列(ArrayMap / ArraySet 等)

  • 缓存类(LruCache 等)

一、Sparse 系列(适合“int/long → 对象”的稀疏映射)

典型类:SparseArray<E>、LongSparseArray<E>、SparseIntArray、SparseLongArray、SparseBooleanArray,全部在 android.util 包中。

设计目标:用更少内存替代 HashMap<Integer, E> / HashMap<Long, E> / HashMap<Integer, Boolean> 等。

1. SparseArray

1.1 功能与使用场景

  • 功能:键为 int、值为任意对象 E 的映射。

  • 对应替代:HashMap<Integer, E>。

  • 典型场景:

    • View 缓存:SparseArray<View> 存储 id → View。

    • 资源/状态映射:status code → handler 对象。

    • Adapter 中 position → 数据对象的临时索引等。

    SparseArray viewCache = new SparseArray<>();

    public View getView(int id, View root) { View cached = viewCache.get(id); if (cached != null) return cached;

    View v = root.findViewById(id);
    viewCache.put(id, v);
    return v;
    

    }

1.2 相比 HashMap的优势 / 特殊优化

  • 不需要装箱(boxing):

    • HashMap<Integer, E> 需要 int → Integer 的装箱;

    • SparseArray 内部直接存 int[] + Object[],避免创建 Integer 对象。

  • 内存占用更小:

    • 不存在 Map.Entry 结构、hash 表等额外对象;

    • 对于小规模映射(几十~几百个元素),总体内存明显低于 HashMap。

  • 数据结构实现:

    • 内部是 两个并行数组:int[] mKeys 和 Object[] mValues;

    • mKeys 有序(按升序),查找使用 二分查找。

1.3 性能 / 内存 / 线程安全

  • 查找时间复杂度:约 O(log n)(二分查找)。

  • 插入/删除复杂度:最坏 O(n)(需要移动数组元素)。

  • 适用规模:Android 官方推荐 小到中等大小(几十~几百,甚至一两千以内)。

  • 线程安全:非线程安全,多线程使用需自行同步。

1.4 适用 / 不适用的场景

适用:

  • key 是 int,数据量不大;

  • 关注内存占用,少量查找/插入;

  • 如:View 缓存、状态映射、Adapter 数据索引。

不适用:

  • 数据规模很大(> 几千甚至上万),且频繁插入/删除;

  • 高并发场景(需要线程安全 map)。

2. LongSparseArray

2.1 功能与使用场景

  • 功能:键为 long 的稀疏映射。

  • 对应替代:HashMap<Long, E>。

  • 场景:

    • 用 long 作为 ID(如数据库 id、时间戳);

    • 存储大范围 id → 对象 的映射。

    LongSparseArray users = new LongSparseArray<>(); users.put(1001L, new User(...)); User u = users.get(1001L);

2.2 相比 HashMap

的优势

  • 避免 Long 装箱,内存占用更小;

  • 查找/插入特性与 SparseArray 类似(有序数组 + 二分查找)。

2.3 性能 / 线程安全

  • 性能特征与 SparseArray 类似;

  • 同样 非线程安全。

2.4 适用 / 不适用场景

适用:

  • long 类型主键映射,如 DB id、时间戳索引;

  • 规模中小,内存敏感。

不适用:

  • 大规模、高频更新;

  • 多线程共享数据结构。

3. SparseIntArray

3.1 功能与使用场景

  • 功能:键为 int、值为 int 的映射。

  • 对应替代:HashMap<Integer, Integer> 或 int[] 辅助结构。

  • 场景:

    • int ID → int 状态值;

    • 枚举值映射、计数器映射等。

    SparseIntArray states = new SparseIntArray(); states.put(1, 100); int value = states.get(1, -1);

3.2 优势与特性

  • 避免双重装箱(Integer 键 + Integer 值);

  • 内部使用 int[] keys + int[] values;

  • 内存极为节省。

4. SparseLongArray

  • 类似 SparseIntArray,但值为 long:

    • 替代:HashMap<Integer, Long>;

    • 场景:int 类型 key → long 类型值(如时间、大小等)。

  • 内部结构:int[] keys + long[] values;

  • 性能/线程安全特征与 SparseIntArray 类似。

5. SparseBooleanArray

5.1 功能与使用场景

  • 功能:键为 int、值为 boolean 的映射。

  • 对应替代:HashMap<Integer, Boolean> 或 Set<Integer>。

  • 常见场景:

    • ListView/RecyclerView 里记录 item 是否选中;

    • 记录某个 id 是否启用 / 打开。

    SparseBooleanArray selectedPositions = new SparseBooleanArray(); selectedPositions.put(3, true); if (selectedPositions.get(3)) { ... }

5.2 优势

  • 避免装箱(Integer、Boolean)、无 Map.Entry;

  • 内部 int[] keys + boolean[] values;

  • 典型地比 HashSet<Integer> 更节省内存(不需要 hash bucket)。

5.3 不适用场景

  • 大规模、高频修改集合;

  • 需要遍历时,复杂度 O(n) 同样较高,不能期望比 Set/Map 更快。

二、Array 系列(ArrayMap / ArraySet 等)

主要类:ArrayMap<K, V>、SimpleArrayMap<K, V>、ArraySet<E> 等。 核心特点:用两个数组(键数组 + 值数组)实现 Map / Set,避免大量小对象。

6. ArrayMap

6.1 功能与使用场景

  • 功能:通用 Map<K, V> 实现,比 HashMap 更省内存,特别是小 Map。

  • 对应替代:HashMap<K, V>。

  • 典型场景:

    • 需要频繁创建小 Map 的地方;

    • Framework 内部大量使用(系统服务、Bundle extras 等)。

    ArrayMap<String, Object> map = new ArrayMap<>(); map.put("name", "Tom"); map.put("age", 18); Object name = map.get("name");

6.2 相比 HashMap的优势 / 特殊优化

  • 内存利用率更高:

    • 使用两个数组:一个存哈希值+索引,一个存 key/value;

    • 减少 Entry 对象创建;

    • 对小集合(<100)整体内存明显小于 HashMap。

  • 按哈希排序存储:

    • 内部维护一个按 hash 排序的数组,通过 二分查找 定位;

    • 冲突时使用线性探测/线性查找。

6.3 性能 / 线程安全

  • 查找:平均 O(log n)(二分查找 hash + 少量线性检查),小集合下常数项非常小;

  • 插入/删除:需要移动数组元素,O(n);

  • 适合小集合:元素多时插入/删除成本显著上升;

  • 线程安全:非线程安全。

6.4 适用 / 不适用示例

适用:

  • 大量创建、销毁小 Map(如参数集合、配置项、少量缓存);

  • 内存敏感系统代码、库代码。

不适用:

  • 上万元素的大 Map,频繁插入/删除;

  • 高并发场景(可用 ConcurrentHashMap)。

7. SimpleArrayMap

  • 与 ArrayMap 非常接近,本质上一样的实现;

  • 主要是 support/AndroidX 中的基础实现类,一般开发者直接用 ArrayMap 更多;

  • 使用/性能/适用场景与 ArrayMap 一致。

8. ArraySet

8.1 功能与使用场景

  • 功能:类似 HashSet<E> 的集合,但更省内存。

  • 对应替代:HashSet<E>。

  • 场景:

    • 需要集合去重、存在性判断,但集合规模不大;

    • 框架内部标志位集合、监听器集合等。

    ArraySet set = new ArraySet<>(); set.add("A"); set.add("B"); if (set.contains("A")) { ... }

8.2 优势 / 特性

  • 内部使用 数组 + 排序 + 二分查找 实现;

  • 无 Entry、无 Node,内存开销低;

  • 对小集合性能极佳(尤其是频繁创建/销毁的情况)。

8.3 不适用场景

  • 元素规模非常大(大量 add/remove),移动数组成本高;

  • 并发集合需求(需要 ConcurrentHashMap/CopyOnWriteArraySet 等)。

三、缓存类:LruCache


虽然更偏“缓存策略”,但在 Android 中用得非常多,也可视作一种数据结构。

9. LruCache

9.1 功能与使用场景

  • 功能:基于 最近最少使用(LRU)策略 的内存缓存。

  • 典型场景:

    • 图片缓存(早期使用,现在更常用三方库,但原理类似);

    • 任意“昂贵对象”缓存(如解析结果、网络数据等)。

    int cacheSize = 4 * 1024 * 1024; // 4MiB LruCache<String, Bitmap> bitmapCache = new LruCache<String, Bitmap>(cacheSize) { @Override protected int sizeOf(String key, Bitmap value) { return value.getByteCount(); } };

    // 使用 bitmapCache.put(url, bitmap); Bitmap bmp = bitmapCache.get(url);

9.2 相比标准 Java 的优势

  • 标准 Java 中没有直接可用的 LRU 缓存类,需要基于 LinkedHashMap 自己实现;

  • LruCache:

    • 提供 可重写的 sizeOf;

    • 有 entryRemoved 回调;

    • 封装了并发访问时的简单同步(内部使用 synchronized)。

9.3 性能 / 线程安全

  • 内部基于 LinkedHashMap,使用访问顺序维护 LRU;

  • 线程安全:

    • 公共方法基本使用 synchronized,适合轻度多线程访问;

    • 高并发场景下吞吐量有限(锁粒度大)。

9.4 适用 / 不适用场景

适用:

  • 中小规模缓存(如每个模块 / 组件级别的对象缓存);

  • 存取频率中等的缓存场景。

不适用:

  • 超大规模、高并发分布式缓存(此类应使用专门缓存框架或服务,如 Redis 等)。

四、综合对比表

数据结构

主要功能

替代/类似标准类

主要优势(相对标准类)

性能特点(查找/插入)

线程安全

典型适用场景

SparseArray

int → E 映射

HashMap<Integer, E>

无装箱,数组结构,无 Entry,对小/中等集合内存占用更小

查找 O(log n),插入/删除 O(n)

否

View 缓存、状态映射、小规模 id→对象映射

LongSparseArray

long → E 映射

HashMap<Long, E>

无装箱,节省内存

同 SparseArray

否

数据库 id、时间戳等 long 主键映射

SparseIntArray

int → int 映射

HashMap<Integer, Integer>

无装箱,纯 int[],内存极低

同 SparseArray

否

状态码、计数器、简单映射

SparseLongArray

int → long 映射

HashMap<Integer, Long>

无装箱,int[] + long[]

同 SparseArray

否

id→时间/大小等 long 值映射

SparseBooleanArray

int → boolean 映射

HashMap<Integer, Boolean> / Set

无装箱,比 Set/Map 更省内存

同 SparseArray

否

选中状态集合、标记位集合

ArrayMap<K, V>

通用 Map

HashMap<K, V>

数组实现,无 Entry,对小 Map 内存显著减少

查找 ~O(log n),插入/删除 O(n)

否

小 Map、大量短生命周期 Map

SimpleArrayMap<K, V>

ArrayMap 的基础实现

同上

同 ArrayMap,一般由库内部使用

同 ArrayMap

否

一般不直接使用,更多用于库/框架内部

ArraySet

集合 Set

HashSet

数组实现,去除 HashNode,内存更小

查找 ~O(log n),插入/删除 O(n)

否

小规模去重集合、标志集合

LruCache<K, V>

LRU 内存缓存

手写 LinkedHashMap LRU 实现

自带 LRU 策略、大小控制、回调,封装好缓存逻辑

依赖 LinkedHashMap,操作为 O(1)

基本是线程安全(synchronized)

图片缓存、对象缓存、解析结果缓存

五、选择建议与示例

  1. 键为 int/long,数据量不大 → 优先用 Sparse 系列

    1. int → 对象:SparseArray<E>

    2. long → 对象:LongSparseArray<E>

    3. int → boolean:SparseBooleanArray

    4. int → int/long:SparseIntArray / SparseLongArray

  2. 通用小 Map / Set → Array 系列

    1. 小 Map,频繁创建/销毁:ArrayMap<K, V>

    2. 小 Set:ArraySet<E>

  3. 需要 LRU 缓存 → LruCache

    1. 简单内存缓存,不想自己实现 LRU:LruCache<K, V>
  4. 线程安全需求

    1. 以上结构大部分 都不是线程安全(LruCache 使用 synchronized,但高并发场景仍有限);

    2. 多线程场景下:

      • 使用外层锁(synchronized / ReentrantLock);

      • 或考虑直接用 Java 标准并发容器(ConcurrentHashMap 等),在性能 / 内存之间权衡。

Android中新增的数据类型看起来主要是针对小数据量的情况,目标是提高性能,降低内存占用

其思路本身可以看做是对Java数据结构的创新,原有的结构属于是大而全的情况,抽象程度更高,适应性更广,面对大数据量情况也可以避免最坏情况,但是对于小数据量则不是很好。