Java 常见数据结构与 Android 使用场景

Java 常见数据结构与 Android 使用场景

本文整理 Java 常见数据结构的核心原理、简化伪代码，以及 Android Framework / Jetpack / 日常开发中常见的使用位置。伪代码用于理解结构和操作流程，不等同于 JDK 或 Android 源码实现。

总览

数据结构	Java 常见实现	核心特点	Android 常见使用场景
数组	int[]、Object[]	连续存储、随机访问快	View 缓存、消息数组、像素数据、资源表
动态数组	ArrayList	自动扩容、按索引访问快	列表数据、Adapter 数据源、Fragment 列表
链表	LinkedList	插入删除灵活、随机访问慢	队列、任务链、较少直接用于 UI 数据
栈	Stack、ArrayDeque	后进先出	Activity 返回栈、Fragment 返回栈、递归解析
队列	Queue、ArrayDeque	先进先出	MessageQueue、任务调度、事件排队
双端队列	Deque、ArrayDeque	两端插入删除	滑动窗口、任务队列、栈替代品
哈希表	HashMap、HashSet	查询快、无序	缓存、对象索引、系统服务注册
有序映射	TreeMap、TreeSet	按 key 排序	区间、优先级、按序遍历
链式哈希表	LinkedHashMap	保持插入顺序或访问顺序	LRU 缓存、图片缓存
稀疏数组	SparseArray	int key 场景省内存	Android 替代 HashMap<Integer, V>
位集合	BitSet	用 bit 表示布尔集合	标记位、权限状态、压缩布尔数组
堆	PriorityQueue	快速获取最大/最小优先级元素	调度器、定时任务、优先级任务
树	TreeNode、自定义结构	层级结构	View 树、布局树、导航图
图	邻接表、邻接矩阵	表达复杂关系	路由导航、依赖关系、任务 DAG
Trie	自定义实现	前缀匹配快	搜索建议、路由匹配、输入法词典
LRU 缓存	LinkedHashMap、LruCache	淘汰最近最少使用数据	图片缓存、资源缓存、网络缓存

---

1. 数组 Array

原理

数组是一段连续内存空间，元素类型相同，创建后长度固定。通过下标访问元素时，可以根据起始地址和下标直接计算目标位置，因此随机访问很快。

特点

• 查询：O(1)
• 按位置更新：O(1)
• 插入 / 删除：平均 O(n)，因为可能需要移动元素
• 长度固定，不能自动扩容

伪代码

class SimpleArray {
    private int[] data;
    private int size;

    SimpleArray(int capacity) {
        data = new int[capacity];
    }

    int get(int index) {
        checkIndex(index);
        return data[index];
    }

    void set(int index, int value) {
        checkIndex(index);
        data[index] = value;
    }

    void add(int value) {
        if (size == data.length) {
            throw new RuntimeException("array is full");
        }
        data[size] = value;
        size++;
    }

    private void checkIndex(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
    }
}

Android 中的使用

• ViewGroup 内部会维护子 View 集合，底层常见思想就是数组或动态数组。
• 图片像素、音频采样、二进制协议解析中经常使用 byte[]、int[]。
• 资源表、样式属性数组、TypedArray 都与数组式索引访问密切相关。
• RecyclerView、Adapter 数据源经常从数组或列表读取指定位置的数据。

---

2. 动态数组 ArrayList

原理

ArrayList 底层是数组。添加元素时，如果容量不足，会创建更大的数组，并把旧数组内容复制过去。它适合频繁按索引访问和尾部追加。

特点

• 随机访问：O(1)
• 尾部追加：均摊 O(1)
• 中间插入 / 删除：O(n)
• 扩容会产生数组复制成本

伪代码

class SimpleArrayList<E> {
    private Object[] elements = new Object[10];
    private int size;

    void add(E value) {
        ensureCapacity(size + 1);
        elements[size] = value;
        size++;
    }

    E get(int index) {
        checkIndex(index);
        return (E) elements[index];
    }

    void removeAt(int index) {
        checkIndex(index);
        for (int i = index; i < size - 1; i++) {
            elements[i] = elements[i + 1];
        }
        elements[size - 1] = null;
        size--;
    }

    private void ensureCapacity(int minCapacity) {
        if (minCapacity <= elements.length) {
            return;
        }
        Object[] newArray = new Object[elements.length * 2];
        copy(elements, newArray);
        elements = newArray;
    }
}

Android 中的使用

• RecyclerView.Adapter 常用 List<T> 或 ArrayList<T> 作为数据源。
• 页面中的列表、搜索结果、消息列表、表单项列表通常使用 ArrayList。
• Fragment、监听器、任务回调等集合也常用动态数组保存。
• Android 源码中大量组件会用数组列表保存观察者、回调和临时对象。

---

3. 链表 LinkedList

原理

链表由节点组成，每个节点保存数据和指向下一个节点的引用。双向链表还保存前一个节点引用。链表不要求连续内存，因此插入和删除节点时只需要改变引用，但查找指定位置需要从头或尾遍历。

特点

• 头尾插入 / 删除：O(1)
• 按值查找：O(n)
• 按索引访问：O(n)
• 每个节点需要额外引用空间

伪代码

class Node<E> {
    E value;
    Node<E> next;
}

class SimpleLinkedList<E> {
    private Node<E> head;

    void addFirst(E value) {
        Node<E> node = new Node<>();
        node.value = value;
        node.next = head;
        head = node;
    }

    E removeFirst() {
        if (head == null) {
            return null;
        }
        E value = head.value;
        head = head.next;
        return value;
    }

    boolean contains(E target) {
        Node<E> current = head;
        while (current != null) {
            if (current.value.equals(target)) {
                return true;
            }
            current = current.next;
        }
        return false;
    }
}

Android 中的使用

• 事件、任务、回调链可以用链表思想组织。
• MessageQueue 内部的消息按时间顺序链接起来，整体表现接近链式队列。
• 日常 Android 开发中，UI 列表数据通常更适合 ArrayList，因为需要频繁按 position 访问。
• OkHttp 的拦截器链、责任链模式虽然不一定用链表类实现，但思想上类似节点逐个传递。

---

4. 栈 Stack

原理

栈是一种后进先出结构，最后放入的元素最先取出。Java 老类是 Stack，但现代代码更推荐用 ArrayDeque 实现栈。

特点

• 入栈：O(1)
• 出栈：O(1)
• 查看栈顶：O(1)
• 适合保存路径、调用历史、撤销记录

伪代码

class SimpleStack<E> {
    private ArrayDeque<E> data = new ArrayDeque<>();

    void push(E value) {
        data.addLast(value);
    }

    E pop() {
        return data.removeLast();
    }

    E peek() {
        return data.peekLast();
    }

    boolean isEmpty() {
        return data.isEmpty();
    }
}

Android 中的使用

• Activity 返回栈：新页面入栈，按返回键时栈顶页面出栈。
• Fragment 返回栈：FragmentManager.addToBackStack() 保存 Fragment 事务历史。
• 导航组件 Navigation 维护目的地返回栈。
• XML / JSON 解析、表达式解析、递归遍历都可能使用栈。

---

5. 队列 Queue

原理

队列是先进先出结构，先进入队列的元素先被处理。它非常适合任务排队、事件排队和生产者消费者模型。

特点

• 入队：O(1)
• 出队：O(1)
• 保证处理顺序
• 可扩展为阻塞队列、延迟队列、优先级队列

伪代码

class SimpleQueue<E> {
    private ArrayDeque<E> data = new ArrayDeque<>();

    void offer(E value) {
        data.addLast(value);
    }

    E poll() {
        return data.pollFirst();
    }

    E peek() {
        return data.peekFirst();
    }
}

Android 中的使用

• Looper + MessageQueue 是 Android 线程消息机制的核心。
• Handler.post(Runnable) 会把任务放入目标线程的消息队列。
• 主线程 UI 更新、点击事件、生命周期调度都会进入消息循环。
• 线程池内部使用工作队列保存等待执行的任务。

---

6. 双端队列 Deque

原理

双端队列允许在头部和尾部进行插入、删除。它既能当队列使用，也能当栈使用。ArrayDeque 通常比 Stack 更适合作为栈。

特点

• 头尾插入：O(1)
• 头尾删除：O(1)
• 可模拟栈、队列、滑动窗口
• 不支持按索引高效访问

伪代码

class SimpleDeque<E> {
    private Object[] elements;
    private int head;
    private int tail;

    void addFirst(E value) {
        head = previousIndex(head);
        elements[head] = value;
    }

    void addLast(E value) {
        elements[tail] = value;
        tail = nextIndex(tail);
    }

    E removeFirst() {
        E value = (E) elements[head];
        elements[head] = null;
        head = nextIndex(head);
        return value;
    }
}

Android 中的使用

• 页面历史、撤销重做、滑动窗口统计可以用 Deque。
• ArrayDeque 可作为轻量级栈，用于遍历 View 树或解析嵌套结构。
• 后台任务调度中，如果需要从两端取任务，可以使用双端队列思想。

---

7. 哈希表 HashMap

原理

哈希表通过 key 的 hashCode() 定位数组下标。多个 key 可能落到同一个位置，这叫哈希冲突。Java 8 之后，冲突链较长时可能从链表转为红黑树，提高极端情况下的查找性能。

特点

• 平均查询 / 插入 / 删除：O(1)
• 极端冲突：可能退化，Java 8 后可树化优化
• 不保证遍历顺序
• key 必须正确实现 equals() 和 hashCode()

伪代码

class SimpleHashMap<K, V> {
    private Entry<K, V>[] table = new Entry[16];

    void put(K key, V value) {
        int index = hash(key) % table.length;
        Entry<K, V> current = table[index];

        while (current != null) {
            if (current.key.equals(key)) {
                current.value = value;
                return;
            }
            current = current.next;
        }

        Entry<K, V> entry = new Entry<>(key, value);
        entry.next = table[index];
        table[index] = entry;
    }

    V get(K key) {
        int index = hash(key) % table.length;
        Entry<K, V> current = table[index];
        while (current != null) {
            if (current.key.equals(key)) {
                return current.value;
            }
            current = current.next;
        }
        return null;
    }
}

Android 中的使用

• 缓存对象：例如按 id 缓存用户、按 url 缓存请求结果。
• 系统服务注册表可以理解为通过名称映射服务获取逻辑。
• ViewModel 存储、Fragment 结果、SavedState 通常有 key-value 数据结构思想。
• Intent extras、Bundle 内部都体现 key-value 映射思想。

---

8. HashSet

原理

HashSet 底层通常基于 HashMap，只关心 key 是否存在，不关心 value。适合去重和快速判断成员是否存在。

特点

• 添加 / 删除 / 判断存在：平均 O(1)
• 元素不重复
• 不保证顺序
• 依赖 equals() 和 hashCode()

伪代码

class SimpleHashSet<E> {
    private HashMap<E, Object> map = new HashMap<>();
    private static final Object PRESENT = new Object();

    void add(E value) {
        map.put(value, PRESENT);
    }

    boolean contains(E value) {
        return map.containsKey(value);
    }

    void remove(E value) {
        map.remove(value);
    }
}

Android 中的使用

• 记录已选中的 item id。
• 防止重复请求、重复注册监听器。
• 权限集合、标签集合、脏数据集合。
• Diff、同步、过滤逻辑中常用集合判断是否存在。

---

9. LinkedHashMap

原理

LinkedHashMap 在哈希表基础上额外维护一条双向链表，因此可以保持插入顺序或访问顺序。设置访问顺序后，最近访问的元素会移动到链表尾部，这常用于实现 LRU 缓存。

特点

• 查询接近 O(1)
• 遍历顺序稳定
• 比 HashMap 多维护链表，内存略高
• 适合缓存和有序映射

伪代码

class LruMap<K, V> extends LinkedHashMap<K, V> {
    private int maxSize;

    LruMap(int maxSize) {
        super(16, 0.75f, true);
        this.maxSize = maxSize;
    }

    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > maxSize;
    }
}

Android 中的使用

• Android LruCache 的思想就是保存有限容量数据，并淘汰最近最少使用的项。
• 图片加载库经常使用 LRU 思想做内存缓存。
• 最近搜索、最近打开页面、最近使用资源都适合用访问顺序映射。
• 需要稳定顺序的 key-value 配置也可以用 LinkedHashMap。

---

10. TreeMap / TreeSet

原理

TreeMap 底层是红黑树，key 会按自然顺序或比较器排序。TreeSet 通常基于 TreeMap 实现。它适合需要有序遍历、范围查询、查找前驱后继的场景。

特点

• 查询 / 插入 / 删除：O(log n)
• key 有序
• 支持范围操作
• 需要 key 可比较或提供 Comparator

伪代码

class SimpleTreeMap<K, V> {
    private TreeNode<K, V> root;
    private Comparator<K> comparator;

    void put(K key, V value) {
        root = insertAndBalance(root, key, value);
    }

    V get(K key) {
        TreeNode<K, V> node = root;
        while (node != null) {
            int result = comparator.compare(key, node.key);
            if (result == 0) {
                return node.value;
            }
            node = result < 0 ? node.left : node.right;
        }
        return null;
    }
}

Android 中的使用

• 按时间、优先级、区间排序的数据可以用 TreeMap。
• 日志、事件、埋点按时间有序组织时可能用到有序结构。
• 动画帧、定时任务、范围索引可以使用树结构思想。
• 日常 Android 开发不如 HashMap 常见，但在需要有序 key 时很有价值。

---

11. SparseArray

原理

SparseArray 是 Android 提供的稀疏数组结构，适合 int 到对象的映射。它避免了 HashMap<Integer, Object> 中 Integer 装箱带来的额外开销。内部通常用两个数组分别保存 key 和 value，并保持 key 有序，查找时使用二分搜索。

特点

• int key 场景更省内存
• 小到中等规模数据很适合
• 查询通常是二分查找：O(log n)
• 插入可能需要移动数组：O(n)

伪代码

class SimpleSparseArray<E> {
    private int[] keys;
    private Object[] values;
    private int size;

    void put(int key, E value) {
        int index = binarySearch(keys, size, key);
        if (index >= 0) {
            values[index] = value;
            return;
        }

        int insertIndex = ~index;
        moveRight(keys, insertIndex);
        moveRight(values, insertIndex);
        keys[insertIndex] = key;
        values[insertIndex] = value;
        size++;
    }

    E get(int key) {
        int index = binarySearch(keys, size, key);
        return index >= 0 ? (E) values[index] : null;
    }
}

Android 中的使用

• SparseArray<View> 常用于按 View id 保存 View，减少 HashMap<Integer, View> 的装箱开销。
• SparseBooleanArray 常用于保存列表 item 的选中状态。
• SparseIntArray 常用于 int 到 int 的映射，例如类型、状态、资源 id 映射。
• Android Framework 源码中大量使用 SparseArray 系列结构优化移动端内存。

---

12. BitSet

原理

BitSet 用一个或多个整数的二进制位表示布尔集合。一个 bit 就能表示 true / false，因此比 boolean[] 更节省空间，尤其适合大量标记位。

特点

• 空间利用率高
• 设置 / 清除 / 判断 bit：接近 O(1)
• 支持位运算，如与、或、异或
• 适合大量布尔状态

伪代码

class SimpleBitSet {
    private long[] words;

    void set(int index) {
        int wordIndex = index / 64;
        int bitIndex = index % 64;
        words[wordIndex] |= (1L << bitIndex);
    }

    boolean get(int index) {
        int wordIndex = index / 64;
        int bitIndex = index % 64;
        return (words[wordIndex] & (1L << bitIndex)) != 0;
    }

    void clear(int index) {
        int wordIndex = index / 64;
        int bitIndex = index % 64;
        words[wordIndex] &= ~(1L << bitIndex);
    }
}

Android 中的使用

• 权限、能力开关、状态标记可以用 bit 位表达。
• View、Window、Intent 等大量使用 flags 保存状态。
• RecyclerView 或列表场景中，可以用位图思想保存大量选中状态。
• 图像处理、字体渲染、协议解析中也常见 bit 操作。

---

13. 堆 Heap / PriorityQueue

原理

堆是一种完全二叉树，通常用数组实现。最小堆保证父节点小于等于子节点，因此堆顶总是最小元素。Java 的 PriorityQueue 默认是最小堆。

特点

• 获取堆顶：O(1)
• 插入：O(log n)
• 删除堆顶：O(log n)
• 适合优先级调度、Top K、合并有序流

伪代码

class MinHeap {
    private int[] data;
    private int size;

    void offer(int value) {
        data[size] = value;
        siftUp(size);
        size++;
    }

    int poll() {
        int result = data[0];
        data[0] = data[size - 1];
        size--;
        siftDown(0);
        return result;
    }

    private void siftUp(int index) {
        while (index > 0) {
            int parent = (index - 1) / 2;
            if (data[parent] <= data[index]) {
                break;
            }
            swap(parent, index);
            index = parent;
        }
    }
}

Android 中的使用

• 定时任务和延迟任务可以用最小堆按触发时间排序。
• 下载、上传、日志上报可以按优先级调度。
• 动画、消息、任务调度内部可能按时间或优先级组织。
• 搜索结果 Top K、排行榜、最近 N 条数据可以用堆优化。

---

14. 树 Tree

原理

树由节点组成，每个节点可以有多个子节点。根节点没有父节点，叶子节点没有子节点。树适合表达层级结构。

特点

• 天然表达父子关系
• 遍历方式包括 DFS 和 BFS
• 二叉搜索树可支持有序查找
• UI、目录、语法结构都常用树表达

伪代码

class TreeNode {
    String name;
    List<TreeNode> children = new ArrayList<>();

    void addChild(TreeNode child) {
        children.add(child);
    }
}

void dfs(TreeNode node) {
    if (node == null) {
        return;
    }
    visit(node);
    for (TreeNode child : node.children) {
        dfs(child);
    }
}

Android 中的使用

• View 层级是典型树结构：DecorView -> ViewGroup -> View。
• 布局测量、布局、绘制会沿着 View 树递归执行。
• Compose 也维护组合树，状态变化后对相关节点进行重组。
• XML 文档、导航图、菜单结构都可以看作树。

---

15. 图 Graph

原理

图由顶点和边组成，用于表达多对多关系。图可以是有向图或无向图，也可以带权重。常见存储方式有邻接表和邻接矩阵。

特点

• 表达关系能力强
• 邻接表适合稀疏图
• 邻接矩阵适合稠密图
• 常见算法包括 BFS、DFS、最短路径、拓扑排序

伪代码

class Graph {
    private Map<String, List<String>> edges = new HashMap<>();

    void addEdge(String from, String to) {
        edges.computeIfAbsent(from, key -> new ArrayList<>()).add(to);
    }

    void bfs(String start) {
        Queue<String> queue = new ArrayDeque<>();
        Set<String> visited = new HashSet<>();

        queue.offer(start);
        visited.add(start);

        while (!queue.isEmpty()) {
            String node = queue.poll();
            visit(node);

            for (String next : edges.getOrDefault(node, List.of())) {
                if (visited.add(next)) {
                    queue.offer(next);
                }
            }
        }
    }
}

Android 中的使用

• Jetpack Navigation 的页面目的地和跳转关系可以看作有向图。
• Gradle 模块依赖、任务依赖是图结构，构建时会进行依赖解析和拓扑排序。
• WorkManager 支持任务链和依赖关系，本质上接近任务图。
• 路由框架、业务流程引擎、权限依赖也常用图思想。

---

16. Trie 前缀树

原理

Trie 用树结构保存字符串，每条路径表示一个前缀。它适合前缀匹配、自动补全、词典查询。

特点

• 查询字符串：O(k)，k 是字符串长度
• 前缀搜索快
• 空间开销可能较大
• 可通过压缩 Trie 优化空间

伪代码

class TrieNode {
    Map<Character, TrieNode> children = new HashMap<>();
    boolean isWord;
}

class Trie {
    private TrieNode root = new TrieNode();

    void insert(String word) {
        TrieNode node = root;
        for (char c : word.toCharArray()) {
            node = node.children.computeIfAbsent(c, key -> new TrieNode());
        }
        node.isWord = true;
    }

    boolean startsWith(String prefix) {
        TrieNode node = root;
        for (char c : prefix.toCharArray()) {
            node = node.children.get(c);
            if (node == null) {
                return false;
            }
        }
        return true;
    }
}

Android 中的使用

• 搜索建议、联系人搜索、输入框自动补全可以使用前缀树思想。
• 输入法词库、拼音匹配、关键字过滤也适合 Trie。
• 路由匹配中，如果需要按路径片段快速查找，也可以使用类似前缀树的结构。
• 大量字符串前缀查询时，Trie 比逐个遍历列表更高效。

---

17. LRU Cache

原理

LRU 是 Least Recently Used 的缩写，表示淘汰最近最少使用的数据。常见实现是 HashMap + 双向链表：HashMap 负责快速定位节点，双向链表负责维护访问顺序。

特点

• 查询：O(1)
• 插入：O(1)
• 淘汰：O(1)
• 非常适合有限内存缓存

伪代码

class LruCache<K, V> {
    private int capacity;
    private Map<K, Node<K, V>> map = new HashMap<>();
    private Node<K, V> head;
    private Node<K, V> tail;

    V get(K key) {
        Node<K, V> node = map.get(key);
        if (node == null) {
            return null;
        }
        moveToTail(node);
        return node.value;
    }

    void put(K key, V value) {
        Node<K, V> node = map.get(key);
        if (node != null) {
            node.value = value;
            moveToTail(node);
            return;
        }

        Node<K, V> newNode = new Node<>(key, value);
        map.put(key, newNode);
        addToTail(newNode);

        if (map.size() > capacity) {
            map.remove(head.key);
            remove(head);
        }
    }
}

Android 中的使用

• android.util.LruCache 是 Android 官方提供的 LRU 缓存工具。
• 图片加载库会用内存 LRU 缓存减少重复解码和网络请求。
• 网络响应、头像、缩略图、字体、反射结果都适合缓存。
• 移动端内存有限，LRU 可以在性能和内存之间取得平衡。

---

18. Bundle / Map 类 Key-Value 结构

原理

Bundle 是 Android 中常见的 key-value 数据容器，用于在组件之间传递少量结构化数据。它和普通 Map 类似，但还涉及序列化、类型约束和跨进程传输。

特点

• 通过字符串 key 存取数据
• 支持基本类型、字符串、数组、Parcelable、Serializable
• 常用于组件通信
• 数据过大可能导致事务失败或性能问题

伪代码

class SimpleBundle {
    private Map<String, Object> values = new HashMap<>();

    void putString(String key, String value) {
        values.put(key, value);
    }

    String getString(String key) {
        Object value = values.get(key);
        return value instanceof String ? (String) value : null;
    }
}

Android 中的使用

• Intent.putExtra() 使用 key-value 传递页面参数。
• Fragment.setArguments(Bundle) 保存 Fragment 初始化参数。
• onSaveInstanceState(Bundle) 保存临时 UI 状态。
• Navigation Safe Args 底层也会把参数放到 Bundle 类结构中传递。

---

19. MessageQueue 消息链

原理

Android 的消息机制由 Handler、Looper、MessageQueue、Message 组成。线程中的 Looper 不断从 MessageQueue 中取消息，然后分发给对应的 Handler 处理。消息按执行时间排序。

特点

• 一个线程通常对应一个 Looper
• MessageQueue 保存待处理消息
• Handler 负责发送和处理消息
• 主线程 UI 更新依赖这套机制

伪代码

class SimpleLooper {
    private MessageQueue queue;

    void loop() {
        while (true) {
            Message msg = queue.next();
            if (msg == null) {
                continue;
            }
            msg.target.dispatchMessage(msg);
        }
    }
}

class SimpleHandler {
    private MessageQueue queue;

    void post(Runnable task) {
        Message msg = Message.obtain();
        msg.callback = task;
        msg.target = this;
        queue.enqueueMessage(msg);
    }

    void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            msg.callback.run();
        } else {
            handleMessage(msg);
        }
    }
}

Android 中的使用

• 主线程的事件循环就是 Looper.loop() 驱动的。
• View.post()、Handler.post() 会把任务加入消息队列。
• 点击事件、绘制请求、生命周期回调都和主线程消息调度有关。
• ANR 的本质之一是主线程消息长时间无法被处理。

---

20. View 树

原理

Android UI 是一棵树。ViewGroup 是容器节点，可以包含子 View；普通 View 是叶子节点。测量、布局、绘制、事件分发都会沿着这棵树传递。

特点

• 适合表达嵌套 UI
• 遍历通常是递归或栈 / 队列
• 父节点影响子节点测量和布局
• 事件分发沿树结构传递

伪代码

abstract class View {
    void measure() {}
    void layout() {}
    void draw() {}
}

class ViewGroup extends View {
    private List<View> children = new ArrayList<>();

    void addView(View child) {
        children.add(child);
    }

    @Override
    void draw() {
        drawSelf();
        for (View child : children) {
            child.draw();
        }
    }
}

Android 中的使用

• Activity 的窗口中最终会挂载一个根 View，一般从 DecorView 开始。
• LinearLayout、FrameLayout、ConstraintLayout 都是 ViewGroup。
• RecyclerView 也是 ViewGroup，但它通过复用子 View 优化大量列表项。
• 自定义 ViewGroup 时，需要理解树形测量、布局和绘制流程。

---

常见选择建议

场景	推荐结构
需要按索引访问列表项	ArrayList
需要先进先出任务队列	ArrayDeque / Queue
需要后进先出历史记录	ArrayDeque
需要快速 key-value 查询	HashMap
int key 映射对象且关注内存	SparseArray
需要去重和快速存在判断	HashSet
需要保留插入顺序	LinkedHashMap
需要最近最少使用缓存	LruCache / LinkedHashMap
需要排序 key 或范围查询	TreeMap
需要按优先级取任务	PriorityQueue
需要表达层级结构	树
需要表达多对多关系	图
需要前缀搜索	Trie

面试回答模板

这个数据结构的核心是：
1. 底层存储方式是什么
2. 查询、插入、删除的时间复杂度是什么
3. 空间开销在哪里
4. Android 中哪个组件或场景使用了它
5. 为什么这个场景适合它

学习建议

• 先把数据结构和 Android 原理绑定起来记，例如：MessageQueue = 队列 / 链式消息结构，ViewGroup = 树，LruCache = HashMap + 双向链表。
• 面试时不要只背复杂度，最好结合 Android 场景说明为什么选它。
• 日常开发中优先使用标准库和 Android 官方结构，只有性能瓶颈明确时再手写数据结构。
• 移动端尤其关注内存，因此 SparseArray、LruCache、对象复用这类结构和思想很常见。