在 Android 开发中，使用高效的数据结构可以减少内存占用并提升性能。以下是一些常见的高效数据结构：
1. SparseArray
- 特点: 替代
HashMap<Integer, Object>，避免自动装箱，减少内存开销。 - 适用场景: 键为整数且数据量较小的场景。
- 示例代码:
SparseArray<String> sparseArray = new SparseArray<>();
sparseArray.put(1, "value1");
String value = sparseArray.get(1);
2. ArrayMap
- 特点: 替代
HashMap，内存占用更小，适合小规模数据。 - 适用场景: 键值对数量较少的场景。
- 示例代码:
ArrayMap<String, String> arrayMap = new ArrayMap<>();
arrayMap.put("key1", "value1");
String value = arrayMap.get("key1");
3. LongSparseArray
- 特点: 类似
SparseArray，但键为long类型。 - 适用场景: 键为长整数的场景。
- 示例代码:
LongSparseArray<String> longSparseArray = new LongSparseArray<>();
longSparseArray.put(1L, "value1");
String value = longSparseArray.get(1L);
4. SparseBooleanArray, SparseIntArray, SparseLongArray
- 特点: 分别用于存储
boolean、int和long类型的值，避免装箱。 - 适用场景: 存储特定类型的值。
- 示例代码:
SparseIntArray sparseIntArray = new SparseIntArray();
sparseIntArray.put(1, 100);
int value = sparseIntArray.get(1);
5. LinkedList
- 特点: 插入和删除操作高效，但随机访问较慢。
- 适用场景: 频繁插入和删除的场景。
- 示例代码:
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("item1");
linkedList.removeFirst();
6. HashSet
- 特点: 基于
HashMap，存储唯一元素，查找速度快。 - 适用场景: 需要快速查找且元素唯一的场景。
- 示例代码:
HashSet<String> hashSet = new HashSet<>();
hashSet.add("item1");
boolean contains = hashSet.contains("item1");
7. TreeSet
- 特点: 基于
TreeMap，元素有序，查找和插入时间复杂度为 O(log n)。 - 适用场景: 需要有序且唯一元素的场景。
- 示例代码:
TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("item1");
boolean contains = treeSet.contains("item1");
8. EnumSet
- 特点: 专为枚举类型设计，内存占用小，性能高。
- 适用场景: 存储枚举类型。
- 示例代码:
enum Day { MONDAY, TUESDAY, WEDNESDAY }
EnumSet<Day> days = EnumSet.of(Day.MONDAY, Day.TUESDAY);
boolean contains = days.contains(Day.MONDAY);
9. Trove Collections
- 特点: 第三方库，提供原始类型集合，避免装箱。
- 适用场景: 需要高性能和低内存占用的场景。
- 示例代码:
TIntArrayList intList = new TIntArrayList();
intList.add(1);
int value = intList.get(0);
10. Circular Buffer (环形缓冲区)
- 特点: 固定大小，循环覆盖旧数据，适合流式数据。
- 适用场景: 需要固定大小缓冲区的场景。
- 示例代码:
CircularBuffer<String> buffer = new CircularBuffer<>(10);
buffer.add("item1");
String item = buffer.get(0);
11. LruCache
- 特点: 基于 LRU 算法，自动移除最近最少使用的数据。
- 适用场景: 缓存数据。
- 示例代码:
LruCache<String, Bitmap> cache = new LruCache<>(maxSize);
cache.put("key1", bitmap);
Bitmap bitmap = cache.get("key1");
12. ConcurrentHashMap
- 特点: 线程安全，适合高并发场景。
- 适用场景: 多线程环境下的键值对存储。
- 示例代码:
ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
map.put("key1", "value1");
String value = map.get("key1");
13. CopyOnWriteArrayList
- 特点: 线程安全，写操作时复制整个列表。
- 适用场景: 读多写少的并发场景。
- 示例代码:
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("item1");
String item = list.get(0);
14. PriorityQueue
- 特点: 基于优先级堆，元素按优先级排序。
- 适用场景: 需要优先级排序的场景。
- 示例代码:
PriorityQueue<Integer> queue = new PriorityQueue<>();
queue.add(1);
int value = queue.poll();
15. WeakHashMap
- 特点: 键为弱引用，适合缓存。
- 适用场景: 缓存数据，避免内存泄漏。
- 示例代码:
WeakHashMap<String, String> weakMap = new WeakHashMap<>();
weakMap.put("key1", "value1");
String value = weakMap.get("key1");
16. LinkedHashMap
- 特点: 保持插入顺序或访问顺序。
- 适用场景: 需要有序键值对的场景。
- 示例代码:
LinkedHashMap<String, String> linkedMap = new LinkedHashMap<>();
linkedMap.put("key1", "value1");
String value = linkedMap.get("key1");
17. ArrayDeque
- 特点: 双端队列，高效插入和删除。
- 适用场景: 需要双端操作的场景。
- 示例代码:
ArrayDeque<String> deque = new ArrayDeque<>();
deque.addFirst("item1");
String item = deque.removeFirst();
18. BitSet
- 特点: 高效存储布尔值，节省内存。
- 适用场景: 需要存储大量布尔值的场景。
- 示例代码:
BitSet bitSet = new BitSet();
bitSet.set(1);
boolean value = bitSet.get(1);
19. Atomic Classes
- 特点: 线程安全，适合高并发场景。
- 适用场景: 多线程环境下的原子操作。
- 示例代码:
AtomicInteger atomicInt = new AtomicInteger(0);
atomicInt.incrementAndGet();
int value = atomicInt.get();
20. Collections.unmodifiableXXX
- 特点: 创建不可变集合，防止意外修改。
- 适用场景: 需要不可变集合的场景。
- 示例代码:
List<String> list = Collections.unmodifiableList(new ArrayList<>());
总结
选择合适的数据结构可以显著减少内存占用并提升性能。根据具体需求选择最合适的工具，避免不必要的内存浪费。
