SparseArray

SparseArray 是 Android 框架提供的专为 int 键、Object 值优化的稀疏数组，核心设计目标是替代「HashMap<Integer, Object>」以节省内存、减少 GC。

SparseArray 的核心价值是「内存优化」，牺牲了部分性能换内存节省，是 Android 特有的「稀疏数据」优化方案。使用时需严格匹配场景：小数据量、int 键、内存敏感场景用它，大数据量或非 int 键场景仍选 HashMap。

以下是其核心优缺点及适用场景分析：

核心优点（对比 HashMap）

1. 内存占用极低（最核心优势）

• 无装箱 / 拆箱开销：HashMap 存储 int 键时会自动装箱为 Integer 对象，而 SparseArray 直接用 int[] keys 数组存储键，避免了 Integer 包装类的内存占用（每个 Integer 约占 16 字节，大量存储时差异显著）；
• 无额外节点对象：HashMap 每个键值对对应一个 Entry 节点（含 key/value/hash/next 指针），而 SparseArray 用两个独立数组（int[] keys + Object[] values）存储键值，无额外对象开销；
• 负载因子与扩容成本低：HashMap 默认负载因子 0.75，扩容时需重建哈希表；SparseArray 无负载因子概念，仅在数组满时扩容，且扩容逻辑更简单（数组拷贝）。

2. GC 友好，减少内存抖动

• 避免了 HashMap 中大量 Integer 包装类、Entry 节点的创建 / 销毁，降低 GC 触发频率，尤其适合 Android 低内存设备或高频增删的场景（如 RecyclerView 数据缓存）。

3. 查找效率可控（针对稀疏数据）

• 基于二分查找定位键的索引（时间复杂度 O (logN)），对于「稀疏数据」（键分布零散、数量≤1000），性能接近 HashMap（O (1)），且无哈希冲突的额外开销。

4. 支持「惰性删除」优化

• 删除元素时并非立即移除数组元素，而是标记为 DELETED 占位符，后续插入 / 查找时复用该位置，减少数组频繁移动的开销（可通过 gc() 手动清理已删除元素）。

核心缺点（局限性）

1. 查找 / 插入效率随数据量下降显著

• 二分查找的时间复杂度 O (logN)，当数据量＞1000 时，性能远低于 HashMap 的 O (1) 哈希查找；
• 插入 / 删除时需移动数组元素（为保持键的有序性），数据量越大，数组拷贝 / 移动的开销越高（HashMap 仅需处理哈希冲突，无大规模移动）。

2. 仅支持 int 键，场景受限

• 键只能是 int 类型，无法存储 long/Integer/String 等其他类型的键，完全无法替代 HashMap<String, Object> 等场景。

3. 不支持并发操作

• 无同步机制，多线程读写时需手动加锁（如 synchronized 或 ReentrantLock），否则会出现数据错乱（HashMap 同理，但 SparseArray 无 ConcurrentHashMap 对应的替代类）。

4. 不支持 null 值（部分版本）

• 早期版本（API < 19）的 SparseArray 不允许 value 为 null（会抛出异常）；高版本虽支持，但 get(int key) 返回 null 时无法区分「键不存在」和「值为 null」（需用 get(int key, Object defaultValue) 规避）。

5. 遍历效率较低

• 遍历需通过 keyAt(int index)/valueAt(int index) 按索引遍历，若需按键遍历，需先二分查找，效率低于 HashMap 的 entrySet 遍历。

延伸：SparseArray 变体（补充场景）

Android 还提供了针对不同类型的 SparseArray 变体，优缺点与核心类一致，仅值类型优化：

适用 / 不适用场景

适用场景（发挥优势）

1. 键为 int 类型，且数据量 ≤1000（如 RecyclerView 的 position 映射、控件 ID 与对象绑定）；
2. 内存敏感场景（如低端机、后台服务），需减少内存占用和 GC；
3. 数据稀疏分布（如键是离散的 int 值：1、100、1000 等）。

不适用场景（避免踩坑）

1. 键非 int 类型（如 String/long）；
2. 数据量＞1000（如海量缓存、数据库查询结果存储）；
3. 高并发读写场景（需手动同步，不如 ConcurrentHashMap 便捷）；
4. 需频繁遍历或随机增删大量数据（数组移动开销大）。

使用建议

1. 小数据量（＜1000）+ int 键 → 优先用 SparseArray 替代 HashMap<Integer, Object>；
2. 大数据量 + int 键 → 仍用 HashMap（性能更优）；
3. 遍历前调用 gc() 清理已删除元素，提升遍历效率；
4. 获取值时优先用 get(int key, defaultValue)，避免 null 歧义；
5. 避免在主线程高频增删大量数据（数组移动可能引发卡顿）。

Android 中 SparseArray 完全使用指南

SparseArray 是 Android 系统提供的高效键值对存储容器（替代 HashMap<Integer, Object>），基于「有序数组 + 二分查找」实现，相比 HashMap 更节省内存、减少自动装箱开销，是 Android 开发中存储「int 键 - 对象值」的首选。

开发中只要满足「int 键 + 小数据量」，就优先用 SparseArray 替代 HashMap：

• 存储对象值：用 SparseArray<V>；
• 存储基本类型：用 SparseIntArray/SparseLongArray/SparseBooleanArray（避免装箱）；
• 数据量 > 1000 或键非 int：用 HashMap/LinkedHashMap。

核心优势（对比 HashMap<Integer, V>）

适用场景：

• 键为 int 类型、值为任意对象；
• 数据量较小（建议 <1000 条，是 Android 开发中最常见的场景）；
• 内存敏感的场景（如 RecyclerView 适配器、列表数据缓存）。

不适用场景：

• 键非 int 类型（如 String、Long）；
• 数据量极大（>1000 条，优先选 HashMap/LinkedHashMap）；
• 高频插入 / 删除（如高频更新的缓存）。

基本使用步骤

1. 引入依赖（无需额外依赖）

SparseArray 是 Android 框架内置类，直接导入即可：

import android.util.SparseArray
// 若存储基本类型（如 int/long），可使用对应的子类：
import android.util.SparseIntArray // int 键-int 值
import android.util.SparseLongArray // int 键-long 值
import android.util.SparseBooleanArray // int 键-boolean 值

2. 核心 API 使用示例（Kotlin/Java）

（1）初始化

// 方式1：默认初始化（初始容量10）
val sparseArray = SparseArray<String>()

// 方式2：指定初始容量（减少扩容次数，推荐）
val sparseArrayWithCapacity = SparseArray<String>(20)

// 子类示例（存储基本类型，无需装箱）
val sparseIntArray = SparseIntArray() // int -> int
val sparseBooleanArray = SparseBooleanArray() // int -> boolean

（2）添加 / 修改元素

// put(int key, V value)：添加/覆盖元素
sparseArray.put(0, "苹果")
sparseArray.put(1, "香蕉")
sparseArray.put(2, "橙子")

// 重复 put 同一 key 会覆盖原有值
sparseArray.put(1, "葡萄") // 键1的值从"香蕉"改为"葡萄"

（3）获取元素

// get(int key)：获取值，无对应key返回null
val value1 = sparseArray.get(1) // 输出：葡萄

// get(int key, V defaultValue)：无key时返回默认值（推荐）
val value3 = sparseArray.get(3, "默认值") // 输出：默认值

// 子类获取（无null，直接返回基本类型）
sparseIntArray.put(0, 100)
val intValue = sparseIntArray.get(0) // 输出：100
val defaultInt = sparseIntArray.get(3, 0) // 输出：0

（4）删除元素

// remove(int key)：删除指定key的元素
sparseArray.remove(2) // 删除键2的"橙子"

// delete(int key)：与remove等价（历史API，推荐用remove）
sparseArray.delete(0) // 删除键0的"苹果"

// clear()：清空所有元素
// sparseArray.clear()

// removeAt(int index)：按索引删除（需先获取索引）
val index = sparseArray.indexOfKey(1) // 获取键1的索引
if (index != -1) {
    sparseArray.removeAt(index) // 删除索引位置的元素
}

（5）遍历元素

SparseArray 是有序容器（按 key 升序排列），遍历方式有 3 种：

// 方式1：按索引遍历（推荐，效率最高）
for (i in 0 until sparseArray.size()) {
    val key = sparseArray.keyAt(i) // 获取第i个元素的key
    val value = sparseArray.valueAt(i) // 获取第i个元素的value
    println("key: $key, value: $value")
}

// 方式2：遍历key（通过key找value，效率较低，避免高频使用）
val keyIterator = sparseArray.keySet().iterator()
while (keyIterator.hasNext()) {
    val key = keyIterator.next()
    val value = sparseArray.get(key)
    println("key: $key, value: $value")
}

// 方式3：Kotlin 扩展遍历（需 API 24+ 或 Core KTX）
sparseArray.forEach { key, value ->
    println("key: $key, value: $value")
}

（6）其他常用 API

// size()：获取元素数量
val size = sparseArray.size() // 输出：当前元素个数

// indexOfKey(int key)：查找key的索引，不存在返回-1
val index = sparseArray.indexOfKey(1) // 存在返回索引，否则-1

// indexOfValue(V value)：查找value的索引（注意：值可能重复，仅返回第一个）
val valueIndex = sparseArray.indexOfValue("葡萄")

// setValueAt(int index, V value)：按索引修改值（效率高）
if (index != -1) {
    sparseArray.setValueAt(index, "蓝莓") // 修改索引位置的值
}

// append(int key, V value)：仅当key不存在时添加（避免覆盖，效率高于put+判断）
sparseArray.append(4, "芒果") // 键4不存在，添加
sparseArray.append(4, "草莓") // 键4已存在，不生效

3. Java 示例（兼容旧项目）

import android.util.SparseArray;

public class SparseArrayDemo {
    public static void main(String[] args) {
        SparseArray<String> sparseArray = new SparseArray<>(10);
        
        // 添加元素
        sparseArray.put(0, "苹果");
        sparseArray.put(1, "香蕉");
        
        // 获取元素
        String value = sparseArray.get(1, "默认值");
        
        // 遍历元素
        for (int i = 0; i < sparseArray.size(); i++) {
            int key = sparseArray.keyAt(i);
            String val = sparseArray.valueAt(i);
            System.out.println("key: " + key + ", value: " + val);
        }
        
        // 删除元素
        sparseArray.remove(0);
    }
}

高级使用技巧

1. 避免自动装箱（Kotlin 注意）

Kotlin 中 int 会自动装箱为 Int，可通过 @JvmField 或直接使用基本类型优化：

// 优化前：自动装箱
val key: Int = 1
sparseArray.put(key, "测试")

// 优化后：直接传基本类型（推荐）
sparseArray.put(1, "测试")

2. 结合 RecyclerView 适配器使用（经典场景）

class MyAdapter : RecyclerView.Adapter<MyViewHolder>() {
    // 存储列表数据（int 位置 -> 数据对象）
    private val data = SparseArray<ItemData>()

    // 添加数据
    fun addItem(position: Int, item: ItemData) {
        data.put(position, item)
        notifyItemInserted(position)
    }

    // 获取数据
    override fun onBindViewHolder(holder: MyViewHolder, position: Int) {
        val item = data.get(position, ItemData.DEFAULT)
        holder.bind(item)
    }

    override fun getItemCount(): Int = data.size()
}

3. 扩容优化

SparseArray 初始容量为 10，当元素超过容量时会扩容（默认翻倍），频繁扩容会影响性能：

// 已知数据量时，指定初始容量（推荐）
val expectedSize = 50
val sparseArray = SparseArray<String>(expectedSize)

4. 与 HashMap 的性能对比（实测）

结论：数据量 <1000 时优先用 SparseArray，>1000 时用 HashMap。

常见坑点与避坑指南

1. key 为负数的问题：

   SparseArray 支持负数 key，但二分查找对负数处理正常，无需额外处理；

2. 遍历中删除元素：

   遍历中直接 remove 会导致索引错乱，需反向遍历或先收集待删除的 key：

   // 错误方式：正向遍历删除会漏元素
   for (i in 0 until sparseArray.size()) {
       if (sparseArray.valueAt(i) == "葡萄") {
           sparseArray.removeAt(i) // 索引错乱，后续元素遍历异常
       }
   }
   
   // 正确方式：反向遍历
   for (i in sparseArray.size() - 1 downTo 0) {
       if (sparseArray.valueAt(i) == "葡萄") {
           sparseArray.removeAt(i)
       }
   }
   

3. indexOfValue 精度问题：

   indexOfValue 仅返回第一个匹配值的索引，若值重复，无法获取所有匹配项；

4. 空值处理：

   get (key) 返回 null 时，需判空或使用 get (key, defaultValue) 避免空指针；

5. 子类使用限制：

   SparseIntArray/SparseLongArray 仅存储基本类型，无法存储 null，需注意默认值。

SparseArray 「惰性删除」实现原理与优化价值

SparseArray 的 “惰性删除”（Lazy Deletion）是其核心优化之一 ——删除元素时不立即从数组中移除，仅标记为 “已删除” 占位符，后续插入 / 查找时复用该位置，避免频繁移动数组元素带来的性能开销。

SparseArray 的 “惰性删除” 核心是「用标记替代立即删除，复用位置替代频繁移动」：

• 实现逻辑：删除标记 DELETED + 插入复用 + 延迟 gc() 压缩；
• 核心价值：降低高频增删场景下的数组移动 / 扩容开销，提升性能；
• 适用场景：小数据量（≤1000）、int 键、高频增删的稀疏数据场景；
• 局限性：大数据量下 gc() 开销高，需结合场景选择（大数据量仍选 HashMap）。

简单来说，惰性删除是 SparseArray 平衡 “内存占用” 和 “操作效率” 的关键设计，也是其相比 HashMap 在小数据量场景更优的核心原因之一。

以下从「实现原理」「核心流程」「优化价值」「注意事项」四方面拆解：

先明确核心数据结构

SparseArray 底层依赖两个核心数组：

private int[] mKeys;          // 存储int键，始终保持升序排列
private Object[] mValues;     // 存储对应值，与mKeys索引一一对应
private int mSize;            // 有效元素数量（不含已删除标记）
private static final Object DELETED = new Object(); // 惰性删除的占位符
private boolean mGarbage = false; // 标记是否有已删除元素，需触发GC清理

• DELETED：静态常量对象，作为 “已删除” 的标记值（替代直接移除数组元素）；
• mGarbage：标记位，标识数组中存在 DELETED 占位符，需在合适时机清理。

惰性删除的核心实现流程

1. 删除操作：仅标记，不移动数组

SparseArray 的 delete(int key)/remove(int key) 方法核心逻辑：

public void delete(int key) {
    // 1. 二分查找key在mKeys中的索引（O(logN)）
    int index = ContainerHelpers.binarySearch(mKeys, mSize, key);
    if (index >= 0) {
        // 2. 不删除数组元素，仅将对应value标记为DELETED
        if (mValues[index] != DELETED) {
            mValues[index] = DELETED;
            mGarbage = true; // 标记存在待清理的删除元素
        }
    }
}
// remove()本质是调用delete()，仅为兼容API
public void remove(int key) {
    delete(key);
}

关键行为：

• 不修改 mKeys 数组，也不移动任何元素的位置；
• 仅将 mValues 对应索引的值替换为 DELETED；
• 置位 mGarbage = true，告知后续操作 “数组中有无效占位符”。

2. 插入操作：优先复用已删除的位置

当调用 put(int key, Object value) 插入元素时，会优先复用已标记为 DELETED 的位置，而非直接扩容或追加：

public void put(int key, Object value) {
    int index = ContainerHelpers.binarySearch(mKeys, mSize, key);

    // 场景1：key已存在 → 直接覆盖值（若为DELETED则恢复为有效值）
    if (index >= 0) {
        mValues[index] = value;
    } else {
        // 场景2：key不存在 → 先处理已删除元素（若有）
        index = ~index; // 二分查找返回的“插入位置”（负数取反）
        
        // 2.1 优先复用DELETED占位符的位置
        if (index < mSize && mValues[index] == DELETED) {
            mKeys[index] = key;
            mValues[index] = value;
            return; // 无需移动数组，直接复用位置
        }

        // 2.2 若没有可复用位置，且有未清理的DELETED → 先触发GC清理
        if (mGarbage && mSize >= mKeys.length) {
            gc(); // 清理DELETED，压缩数组
            // 清理后重新计算插入位置（数组已压缩，索引可能变化）
            index = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
        }

        // 2.3 扩容/插入新元素（无复用位置时）
        if (mSize >= mKeys.length) {
            int newSize = ArrayUtils.idealIntArraySize(mSize + 1); // 扩容
            int[] newKeys = new int[newSize];
            Object[] newValues = new Object[newSize];
            System.arraycopy(mKeys, 0, newKeys, 0, mKeys.length);
            System.arraycopy(mValues, 0, newValues, 0, mValues.length);
            mKeys = newKeys;
            mValues = newValues;
        }
        // 移动数组元素，腾出插入位置（仅当无复用位置时才执行）
        if (mSize - index != 0) {
            System.arraycopy(mKeys, index, mKeys, index + 1, mSize - index);
            System.arraycopy(mValues, index, mValues, index + 1, mSize - index);
        }
        mKeys[index] = key;
        mValues[index] = value;
        mSize++;
    }
}

核心优化点：

• 插入时先检查目标位置是否为 DELETED，若为则直接复用，避免数组移动；
• 仅当无复用位置且数组满时，才触发扩容和元素移动，大幅减少数组操作开销。

3. 触发 GC 清理：压缩数组，移除 DELETED

SparseArray 提供 gc() 方法（私有，自动触发），用于清理 DELETED 占位符，压缩数组：

private void gc() {
    int n = mSize;
    int o = 0; // 新数组的有效索引
    int[] keys = mKeys;
    Object[] values = mValues;

    // 遍历数组，将非DELETED的元素移到数组前端
    for (int i = 0; i < n; i++) {
        Object val = values[i];
        if (val != DELETED) {
            if (i != o) {
                keys[o] = keys[i];
                values[o] = val;
                values[i] = null; // 释放原位置引用，便于GC
            }
            o++;
        }
    }

    mGarbage = false; // 重置标记
    mSize = o; // 更新有效元素数量
}

触发时机（自动，无需手动调用）：

• 插入元素时，若数组已满且存在 DELETED；

• 调用size()/ keyAt() / valueAt() 等遍历 / 计数方法时：

  public int size() {
      if (mGarbage) {
          gc(); // 先清理，再返回有效数量
      }
      return mSize;
  }
  

惰性删除的优化价值

1. 避免频繁数组移动，提升增删效率

普通数组删除元素需 “删除位置后所有元素向前移动”（O (N) 开销），而 SparseArray 仅标记 DELETED（O (1)），仅在必要时触发一次 gc() 压缩数组，大幅降低高频增删场景的开销（如 RecyclerView 中频繁更新 position 映射）。

2. 减少数组扩容次数

复用 DELETED 位置相当于 “回收” 无效空间，减少插入时的扩容频率（扩容需数组拷贝，开销高）。

3. 内存更高效

DELETED 是静态常量，仅占用一个对象内存，相比每次删除都创建 / 销毁数组元素，内存开销更低；且 gc() 清理时会释放无效引用，避免内存泄漏。

注意事项（惰性删除的潜在问题）

1. 需手动触发 gc（可选）

若需主动清理 DELETED（如遍历前），可调用 trimToSize() 或 size()（间接触发 gc()）：

sparseArray.trimToSize(); // 强制触发gc，压缩数组

2. 遍历需用官方 API，避免踩 DELETED

不能直接遍历 mValues 数组（可能包含 DELETED），需用 keyAt(int index)/valueAt(int index)：

// 正确遍历方式
for (int i = 0; i < sparseArray.size(); i++) {
    int key = sparseArray.keyAt(i);
    Object value = sparseArray.valueAt(i);
}

keyAt()/valueAt() 会先触发 gc()，确保返回的是有效元素。

3. 数据量过大时，gc () 开销不可忽视

gc() 是 O (N) 操作，若 SparseArray 存储大量元素（＞1000），频繁触发 gc() 会导致性能下降（这也是 SparseArray 不适合大数据量的原因之一）。

SparseArray 惰性删除的优缺点（附场景适配分析）

惰性删除是 SparseArray “扬长避短” 的设计 ——在小数据量、高频增删、内存敏感的 Android 场景下，用 “延迟清理的小成本” 换 “即时操作的高效率”；但超出该场景后，延迟清理的成本会抵消所有收益，甚至导致性能更差。

其核心逻辑是 “取舍”：放弃大数据量下的性能，换取小数据量下的内存和高频操作优势，这也是 SparseArray 作为 Android 专属容器的核心设计思路。

惰性删除是 SparseArray 为平衡「内存开销」和「操作效率」设计的核心机制，其优缺点高度绑定 “稀疏数据、小数据量” 的适用场景 —— 在适配场景下优势显著，超出场景则缺点凸显。

具体分析如下：

核心优点（适配场景下的核心价值）

1. 大幅降低删除操作的即时开销

• 原理：删除时仅将 value 标记为 DELETED（O (1) 操作），无需像普通数组那样 “删除位置后所有元素向前移动”（O (N) 开销），也无需修改 key 数组；
• 价值：高频删除场景（如 RecyclerView 动态更新数据、临时缓存清理）下，避免频繁数组移动导致的性能抖动，尤其适合 Android 主线程操作。

2. 减少数组扩容次数，提升插入效率

• 原理：插入新元素时优先复用 DELETED 占位的位置，无需立即扩容或移动数组元素；
• 价值：扩容（数组拷贝）是高开销操作，复用无效位置相当于 “回收” 已占用的数组空间，减少扩容频率，小数据量下插入效率接近 HashMap。

3. 内存占用更稳定，减少 GC 触发

• 原理：DELETED 是静态常量（仅 1 个对象），替代 “删除元素→新建数组→拷贝元素” 的内存波动；

  避免频繁扩容导致的临时数组创建 / 销毁，降低内存碎片；

• 价值：Android 低内存设备（如入门机）或长生命周期组件（如 Service）中，减少 GC 触发频率，提升应用稳定性。

4. 保持 key 数组的有序性，不影响二分查找

• 原理：删除仅标记 value，不改动 key 数组的顺序和内容，二分查找（O (logN)）的逻辑完全不受影响；
• 价值：查找效率始终稳定，不会因频繁删除出现性能退化。

核心缺点（超出适配场景的问题）

1. 引入 “延迟清理” 成本，可能触发批量开销

• 原理：惰性删除的 “债” 最终要通过 gc() 偿还 ——gc() 需遍历数组、压缩有效元素（O (N) 操作）；

• 问题： 当gc()触发时（如插入满数组、调用size()/keyAt()），会一次性执行批量清理，若数据量较大（＞1000），可能引发主线程卡顿；

  频繁增删时，gc()会被反复触发，叠加 O (N) 开销，性能反超普通数组 / HashMap。

2. 数组空间 “假占用”，内存利用率降低

• 原理：已标记 DELETED 的位置仍占用数组空间，未被真正释放；

• 问题：

  ✅ 大量删除后未触发gc()时，数组实际占用空间远大于有效元素所需空间（比如数组长度 100，仅 10 个有效元素，90 个DELETED）；

  ✅ 小内存设备中，可能导致 “数组已占空间→无法分配其他内存” 的假溢出。

3. 遍历 / 计数需先清理，增加间接开销

• 原理：调用 size()/keyAt()/valueAt() 等遍历 / 计数方法时，会先触发 gc() 清理无效元素；

• 问题：

  ✅ 遍历前强制gc()，若数组中存在大量DELETED，遍历的实际开销 = O (N)（gc） + O (M)（遍历有效元素），效率低于普通数组；

  ✅ 新手易踩坑：直接遍历mValues数组会拿到DELETED占位符，必须用官方 API（keyAt()/valueAt()），增加使用成本。

4. 数据量越大，缺点越显著

• 原理：惰性删除的优势建立在 “小数据量（≤1000）、稀疏分布” 的基础上；

• 问题：

  ✅ 数据量＞1000 时，gc()的 O (N) 开销会远超 “避免数组移动” 的收益，性能远低于 HashMap（O (1) 哈希查找）；

  ✅ 密集数据（键连续，如 1、2、3…）场景下，几乎无复用DELETED位置的机会，惰性删除仅增加标记 / 清理成本，无任何收益。

5. 无法区分 “值为 null” 和 “键已删除”（高版本兼容问题）

• 原理：早期版本 SparseArray 不支持 null 值，高版本支持后，get(key) 返回 null 时，无法区分 “键不存在”“值为 null”“键已被标记删除”；
• 问题：需额外调用 containsKey(key) 校验，增加代码复杂度，而 HashMap 可通过 containsKey() 直接判断。

优缺点对比表

适配 / 规避建议

适合用惰性删除的场景

1. 键为 int 类型，数据量 ≤ 1000（如控件 ID 映射、RecyclerView position 缓存）；
2. 高频增删、低频遍历（如临时数据缓存）；
3. Android 主线程操作（需避免频繁数组移动导致的卡顿）。

避免用惰性删除的场景

1. 数据量 ＞ 1000（直接用 HashMap，放弃 SparseArray）；
2. 高频遍历、低频增删（如列表数据存储）；
3. 内存极度紧张，且需精准控制数组空间（手动调用 trimToSize() 触发 gc() 后使用）。

优化技巧

1. 遍历前手动调用 trimToSize() 触发 gc()，避免遍历过程中重复清理；
2. 批量删除后及时调用 gc()，释放无效空间；
3. 获取值时用 get(key, defaultValue)，规避 null 值歧义；
4. 大数据量场景直接替换为 HashMap，放弃 SparseArray 的内存优化。