本文同步发表于我的微信公众号，微信搜索 程语新视界 即可关注，每个工作日都有文章更新

一、标准集合容器

1. Array（数组）

// 创建方式
let arr1: number[] = [1, 2, 3];
let arr2: Array<string> = ['a', 'b', 'c'];

// 常用操作
arr1.push(4);          // 添加元素
arr2.pop();            // 移除末尾元素
arr1.forEach(item => console.log(item));

2. Set（集合）

// 创建方式
let set1: Set<number> = new Set([1, 2, 3]);
let set2 = new Set<string>();

// 常用操作
set1.add(4);           // 添加元素
set1.delete(1);        // 删除元素
set1.has(2);           // 检查存在

3. Map（字典）

// 创建方式
let map1: Map<string, number> = new Map([['a', 1], ['b', 2]]);
let map2 = new Map<number, boolean>();

// 常用操作
map1.set('c', 3);      // 添加键值对
map1.get('a');         // 获取值
map1.delete('b');      // 删除键值对

4. WeakSet/WeakMap（弱引用集合）

// 创建方式
let weakSet = new WeakSet<object>();
let weakMap = new WeakMap<object, string>();

// 特点：键必须是对象，不阻止垃圾回收

二、鸿蒙特有容器

1. LinkedList（双向链表）

import LinkedList from '@ohos.util.LinkedList';

// 创建方式
let list = new LinkedList<number>();

// 常用操作
list.add(1);           // 添加元素
list.addFirst(0);      // 头部添加
list.removeLast();     // 移除尾部

2. ArrayList（动态数组）

import ArrayList from '@ohos.util.ArrayList';

// 创建方式
let arrayList = new ArrayList<string>();

// 常用操作
arrayList.add('a');
arrayList.get(0);      // 获取元素
arrayList.sort();      // 排序

3. HashMap/TreeMap（哈希/树映射）

import HashMap from '@ohos.util.HashMap';
import TreeMap from '@ohos.util.TreeMap';

// HashMap示例
let hashMap = new HashMap<string, number>();
hashMap.set('key', 123);

// TreeMap示例（自动排序）
let treeMap = new TreeMap<number, string>();
treeMap.set(3, 'c');
treeMap.set(1, 'a');

4. LightWeightMap/LightWeightSet（轻量级容器）

import { LightWeightMap, LightWeightSet } from '@ohos.util';

// LightWeightMap示例
let lwMap = new LightWeightMap<string, number>();
lwMap.set('score', 100);

// LightWeightSet示例
let lwSet = new LightWeightSet<number>();
lwSet.add(42);

三、队列和栈结构

1. Queue（队列）

import Queue from '@ohos.util.Queue';

// 创建方式
let queue = new Queue<number>();

// 常用操作
queue.add(1);          // 入队
queue.poll();          // 出队

2. Deque（双端队列）

import Deque from '@ohos.util.Deque';

// 创建方式
let deque = new Deque<string>();

// 常用操作
deque.addFirst('a');
deque.addLast('z');

3. Stack（栈）

import Stack from '@ohos.util.Stack';

// 创建方式
let stack = new Stack<boolean>();

// 常用操作
stack.push(true);      // 压栈
stack.pop();           // 弹栈

四、容器性能对比

容器类型	插入性能	索引访问	查找性能（值）	删除性能	有序性	重复元素	内存连续性	适用场景
Array	O(1)末尾O(n)中间	O(1)	O(n)	O(n)	有序	允许	连续	随机访问、高频遍历
LinkedList	O(1)	O(n)	O(n)	O(1)	有序	允许	非连续	频繁头尾操作
ArrayList	O(1)末尾O(n)中间	O(1)	O(n)	O(n)	有序	允许	连续	动态数组需求
HashSet	O(1)	不支持	O(1)	O(1)	无序	不允许	哈希分散	快速存在性检查
TreeSet	O(log n)	不支持	O(log n)	O(log n)	键有序	不允许	树结构	有序唯一值集合
HashMap	O(1)	不支持	O(1)	O(1)	无序	键唯一	哈希分散	键值对快速查找
TreeMap	O(log n)	不支持	O(log n)	O(log n)	键有序	键唯一	树结构	有序键值对
Queue	O(1)队尾	O(n)	O(n)	O(1)队首	有序	允许	依赖实现	FIFO队列
Deque	O(1)两端	O(n)	O(n)	O(1)两端	有序	允许	依赖实现	双端操作
Stack	O(1)栈顶	O(n)	O(n)	O(1)栈顶	有序	允许	依赖实现	LIFO栈

五、容器转换方法

1. 数组与其他容器互转

// Array转Set
let arr = [1, 2, 3];
let setFromArr = new Set(arr);

// Set转Array
let arrFromSet = Array.from(setFromArr);

// Map转Array
let map = new Map([['a', 1], ['b', 2]]);
let entriesArr = Array.from(map.entries());

2. 容器间转换

// ArrayList转Array
let arrayList = new ArrayList<number>();
arrayList.add(1);
let arr = arrayList.convertToArray();

// HashMap转Map
let hashMap = new HashMap<string, number>();
hashMap.set('key', 123);
let map = new Map(hashMap.entries());

六、实际应用示例

1. 使用HashMap缓存数据

import HashMap from '@ohos.util.HashMap';

@Entry
@Component
struct CacheExample {
  private cache = new HashMap<string, string>();

  build() {
    Column() {
      Button('添加缓存')
        .onClick(() => {
          this.cache.set('user_123', JSON.stringify({
            name: '张三',
            age: 25
          }));
        })
      
      Button('读取缓存')
        .onClick(() => {
          const userData = this.cache.get('user_123');
          console.log(userData);
        })
    }
  }
}

2. 使用Queue处理任务

import Queue from '@ohos.util.Queue';

class TaskManager {
  private taskQueue = new Queue<() => void>();
  
  addTask(task: () => void) {
    this.taskQueue.add(task);
  }
  
  processTasks() {
    while (this.taskQueue.length > 0) {
      const task = this.taskQueue.poll();
      task?.();
    }
  }
}

3. 使用TreeMap实现排行榜

import TreeMap from '@ohos.util.TreeMap';

@Entry
@Component
struct Leaderboard {
  private scores = new TreeMap<number, string>((a, b) => b - a); // 降序排列

  build() {
    Column() {
      Button('添加分数')
        .onClick(() => {
          const name = `玩家${Math.floor(Math.random() * 100)}`;
          const score = Math.floor(Math.random() * 1000);
          this.scores.set(score, name);
        })
      
      ForEach(Array.from(this.scores.entries()), ([score, name]) => {
        Text(`${name}: ${score}`).fontSize(16)
      })
    }
  }
}

七、总结

1. 选择合适容器：

   • 需要键值对：优先考虑HashMap
   • 需要自动排序：使用TreeMap
   • 简单集合：Array或Set
   • 频繁插入删除：LinkedList

2. 性能考虑：

   • 大数据集避免使用Array查找
   • 频繁修改的集合考虑轻量级容器
   • 线程安全场景使用Concurrent容器

3. 内存管理：

   • 临时数据使用WeakMap/WeakSet
   • 及时清理不再使用的容器引用

4. API熟悉：

   • 掌握各种容器的迭代方式
   • 了解容量调整机制
   • 熟悉各容器的边界条件处理