仓颉语言标准库深度解析：集合框架与并发编程实战

封面

封面：仓颉标准库全景 - 从集合框架到并发编程的完整生态

📌 导读：深入仓颉语言标准库，系统解析集合框架、并发编程、异步IO等核心模块。通过大量实战案例，掌握标准库的最佳实践，构建高性能、类型安全的鸿蒙原生应用。

核心收获：

  • 📦 掌握仓颉集合框架的完整体系
  • ⚡ 学会高效的并发编程模式
  • 🎯 理解协程与异步编程的底层原理
  • 🔧 实战迭代器与闭包的高级用法
  • 🚀 性能优化技巧与最佳实践
  • 💡 标准库源码剖析与设计哲学

📖 目录

一、仓颉标准库概览

1.1 标准库架构

标准库架构图

图1：仓颉标准库分层架构 - 从底层运行时到高层抽象的完整体系

架构说明：

仓颉标准库采用分层模块化架构，从底层到高层依次为：

  1. 核心运行时层：

    • 🔧 内存管理（GC、引用计数）
    • ⚡ 线程调度与协程运行时
    • 🛡️ 类型系统支持
    • 📊 反射与元编程

  2. 基础类型层：

    • 📝 基本类型（Int、Float、String、Bool）
    • 🔢 数值类型与数学库
    • 📅 日期时间（DateTime）
    • 🌐 字符串处理与编码

  3. 集合框架层：

    • 📚 List、Array、Set、Map
    • 🔄 迭代器与生成器
    • 🎯 专用集合（Queue、Stack、Deque）
    • 📊 不可变集合

  4. 并发编程层：

    • 🧵 Thread、Coroutine
    • 🔒 同步原语（Mutex、RWLock、Semaphore）
    • 📡 Channel通信
    • ⚛️ 原子操作（Atomic）

  5. IO与网络层：

    • 📁 文件IO（File、Path）
    • 🌐 网络编程（Socket、HTTP）
    • 📦 序列化（JSON、XML）
    • 🔐 加密与安全

  6. 鸿蒙集成层：

    • 🎨 ArkUI绑定
    • 📱 系统API封装
    • 🔄 分布式能力
    • 📊 性能监控

设计理念：

  • ✅ 零成本抽象：高层API无运行时开销
  • ✅ 类型安全：编译期保证正确性
  • ✅ 易用性：符合直觉的API设计
  • ✅ 高性能：针对鸿蒙生态深度优化

1.2 标准库模块清单

模块 功能 核心类型 常用场景
std.collection 集合框架 ArrayList, HashMap, HashSet 数据存储与管理
std.concurrent 并发编程 Thread, Mutex, Channel 多线程协作
std.async 异步编程 Future, async/await, Coroutine 高并发IO
std.io IO操作 File, Reader, Writer 文件与网络IO
std.string 字符串 String, StringBuilder 文本处理
std.math 数学库 Math, Random 数值计算
std.time 时间处理 DateTime, Duration 时间相关操作
std.encoding 编码转换 JSON, Base64, UTF8 序列化与编码
std.net 网络编程 Socket, HTTP, TCP/UDP 网络通信
std.sync 同步原语 Atomic, Barrier, CountDownLatch 线程同步

1.3 导入标准库

// 导入整个模块
import std.collection.*
import std.concurrent.*

// 导入特定类型
import std.collection.{ArrayList, HashMap}
import std.io.{File, FileMode}

// 使用别名避免命名冲突
import std.collection.ArrayList as List
import std.concurrent.Thread as CjThread

// 示例：创建集合
func main() {
    let list = ArrayList<Int>()
    list.add(1)
    list.add(2)
    list.add(3)
    
    println("List: ${list}")  // List: [1, 2, 3]
}

二、集合框架详解

2.1 集合体系结构
Collection
List
Set
Queue
ArrayList
LinkedList
HashSet
TreeSet
ArrayDeque
Map
HashMap
TreeMap

图2：仓颉集合框架继承体系 - 清晰的接口设计与实现关系

集合框架核心接口：

// Collection接口：所有集合的基础
interface Collection<T> {
    func size(): Int
    func isEmpty(): Bool
    func contains(element: T): Bool
    func add(element: T): Bool
    func remove(element: T): Bool
    func clear(): Unit
    func toArray(): Array<T>
}

// List接口：有序集合
interface List<T> : Collection<T> {
    func get(index: Int): T
    func set(index: Int, element: T): T
    func insert(index: Int, element: T): Unit
    func removeAt(index: Int): T
    func indexOf(element: T): Option<Int>
}

// Set接口：不重复集合
interface Set<T> : Collection<T> {
    // Set特有方法
    func union(other: Set<T>): Set<T>
    func intersect(other: Set<T>): Set<T>
    func difference(other: Set<T>): Set<T>
}

// Map接口：键值对集合
interface Map<K, V> {
    func size(): Int
    func isEmpty(): Bool
    func containsKey(key: K): Bool
    func get(key: K): Option<V>
    func put(key: K, value: V): Option<V>
    func remove(key: K): Option<V>
    func keys(): Set<K>
    func values(): Collection<V>
}

2.2 ArrayList详解

底层实现：动态数组，自动扩容

import std.collection.ArrayList

// 创建ArrayList
func arrayListDemo() {
    // 方式1：默认容量
    let list1 = ArrayList<String>()
    
    // 方式2：指定初始容量
    let list2 = ArrayList<Int>(capacity: 100)
    
    // 方式3：从数组创建
    let list3 = ArrayList<Int>([1, 2, 3, 4, 5])
    
    // 方式4：使用构建器
    let list4 = ArrayList<String> {
        add("Alice")
        add("Bob")
        add("Charlie")
    }
    
    // 添加元素
    list1.add("Hello")
    list1.add("World")
    
    // 批量添加
    list1.addAll(["Foo", "Bar"])
    
    // 访问元素
    let first = list1[0]  // "Hello"
    let second = list1.get(1)  // "World"
    
    // 修改元素
    list1[0] = "Hi"
    list1.set(1, "Cangjie")
    
    // 插入元素
    list1.insert(1, "Beautiful")  // [Hi, Beautiful, Cangjie, Foo, Bar]
    
    // 删除元素
    list1.removeAt(0)  // 删除索引0
    list1.remove("Foo")  // 删除特定元素
    
    // 查找
    let index = list1.indexOf("Bar")  // Some(2)
    let contains = list1.contains("Hi")  // true
    
    // 遍历
    for item in list1 {
        println(item)
    }
    
    // 使用迭代器
    let iter = list1.iterator()
    while iter.hasNext() {
        println(iter.next())
    }
}

性能特性：

操作 时间复杂度 说明
add(T) O(1)* 尾部添加，偶尔扩容O(n)
insert(Int, T) O(n) 需要移动元素
get(Int) O(1) 直接索引访问
set(Int, T) O(1) 直接索引修改
remove(T) O(n) 需要查找+移动
removeAt(Int) O(n) 需要移动元素
contains(T) O(n) 线性查找

2.3 HashMap详解

底层实现：哈希表 + 链表/红黑树（冲突解决）

import std.collection.HashMap

func hashMapDemo() {
    // 创建HashMap
    let map = HashMap<String, Int>()
    
    // 添加键值对
    map.put("Alice", 25)
    map.put("Bob", 30)
    map.put("Charlie", 35)
    
    // 使用构建器
    let ages = HashMap<String, Int> {
        put("David", 28)
        put("Eve", 32)
    }
    
    // 访问元素
    let age = map.get("Alice")  // Some(25)
    let missing = map.get("Unknown")  // None
    
    // 使用getOrElse提供默认值
    let defaultAge = map.getOrElse("Unknown", 0)  // 0
    
    // 更新元素
    map.put("Alice", 26)  // 返回旧值 Some(25)
    
    // 条件插入（key不存在时才插入）
    map.putIfAbsent("Frank", 40)
    
    // 删除元素
    let removed = map.remove("Bob")  // Some(30)
    
    // 检查
    let hasKey = map.containsKey("Charlie")  // true
    let hasValue = map.containsValue(35)  // true
    
    // 遍历所有键
    for key in map.keys() {
        println("Key: ${key}")
    }
    
    // 遍历所有值
    for value in map.values() {
        println("Value: ${value}")
    }
    
    // 遍历键值对
    for (key, value) in map.entries() {
        println("${key} -> ${value}")
    }
    
    // 函数式操作
    map.forEach((key, value) => {
        println("${key}: ${value} years old")
    })
    
    // 批量操作
    map.putAll(HashMap<String, Int> {
        put("Grace", 29)
        put("Henry", 33)
    })
}

哈希冲突处理：

graph LR
    A[Hash函数] --> B{冲突?}
    B -->|否| C[直接存储]
    B -->|是| D{链表长度}
    D -->|< 8| E[链表存储]
    D -->|≥ 8| F[转红黑树]
    
    E --> G[O n查找]
    F --> H[O log n查找]
    
    style C fill:#e8f5e9
    style F fill:#e3f2fd
    style G fill:#fff3e0
    style H fill:#e8f5e9

图3：HashMap冲突解决策略 - 链表与红黑树的自适应切换

性能特性：

操作 平均时间 最坏情况 说明
put(K, V) O(1) O(log n) 哈希冲突时
get(K) O(1) O(log n) 哈希冲突时
remove(K) O(1) O(log n) 哈希冲突时
containsKey(K) O(1) O(log n) 哈希冲突时

2.4 HashSet详解

import std.collection.HashSet

func hashSetDemo() {
    // 创建HashSet
    let set1 = HashSet<Int>()
    set1.add(1)
    set1.add(2)
    set1.add(3)
    set1.add(2)  // 重复元素被忽略
    
    println(set1.size())  // 3
    
    // 从数组创建
    let set2 = HashSet<Int>([3, 4, 5])
    
    // 集合运算
    let union = set1.union(set2)  // {1, 2, 3, 4, 5}
    let intersect = set1.intersect(set2)  // {3}
    let diff = set1.difference(set2)  // {1, 2}
    
    // 子集判断
    let isSubset = HashSet<Int>([1, 2]).isSubsetOf(set1)  // true
    
    // 遍历
    for item in set1 {
        println(item)
    }
}

2.5 集合选择指南
是
否
是
否
是
否
是
否
是
否
需要集合?
需要键值对?
需要排序?
允许重复?
TreeMap
HashMap
需要随机访问?
需要排序?
ArrayList
LinkedList
TreeSet
HashSet

图4：集合类型选择决策树 - 快速选择最合适的集合类型

选择建议：

需求 推荐集合 理由
需要快速随机访问 ArrayList O(1)索引访问
频繁插入删除 LinkedList O(1)插入删除
需要唯一性 HashSet 自动去重
需要有序且唯一 TreeSet 自动排序
键值对映射 HashMap 快速查找
需要排序的映射 TreeMap 按键排序
FIFO队列 Queue 队列语义
双端操作 Deque 两端都可操作

三、迭代器与函数式编程

3.1 迭代器模式

// Iterator接口
interface Iterator<T> {
    func hasNext(): Bool
    func next(): T
}

// Iterable接口
interface Iterable<T> {
    func iterator(): Iterator<T>
}

// 自定义迭代器示例
class Range : Iterable<Int> {
    private let start: Int
    private let end: Int
    private let step: Int
    
    init(start: Int, end: Int, step: Int = 1) {
        this.start = start
        this.end = end
        this.step = step
    }
    
    func iterator(): Iterator<Int> {
        return RangeIterator(start, end, step)
    }
}

class RangeIterator : Iterator<Int> {
    private var current: Int
    private let end: Int
    private let step: Int
    
    init(start: Int, end: Int, step: Int) {
        this.current = start
        this.end = end
        this.step = step
    }
    
    func hasNext(): Bool {
        return current < end
    }
    
    func next(): Int {
        let value = current
        current += step
        return value
    }
}

// 使用示例
func iteratorDemo() {
    let range = Range(0, 10, 2)
    for i in range {
        println(i)  // 0, 2, 4, 6, 8
    }
}

3.2 函数式API

import std.collection.*

func functionalDemo() {
    let numbers = ArrayList<Int>([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    
    // map: 转换每个元素
    let doubled = numbers.map(x => x * 2)
    // [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
    
    // filter: 筛选元素
    let evens = numbers.filter(x => x % 2 == 0)
    // [2, 4, 6, 8, 10]
    
    // reduce: 聚合操作
    let sum = numbers.reduce(0, (acc, x) => acc + x)
    // 55
    
    // 链式调用
    let result = numbers
        .filter(x => x > 5)
        .map(x => x * x)
        .reduce(0, (acc, x) => acc + x)
    // 6² + 7² + 8² + 9² + 10² = 330
    
    // forEach: 遍历操作
    numbers.forEach(x => println(x))
    
    // any: 是否存在满足条件的元素
    let hasEven = numbers.any(x => x % 2 == 0)  // true
    
    // all: 是否所有元素都满足条件
    let allPositive = numbers.all(x => x > 0)  // true
    
    // find: 查找第一个满足条件的元素
    let firstEven = numbers.find(x => x % 2 == 0)  // Some(2)
    
    // partition: 分组
    let (evens2, odds) = numbers.partition(x => x % 2 == 0)
    // evens: [2, 4, 6, 8, 10], odds: [1, 3, 5, 7, 9]
    
    // groupBy: 分组映射
    let grouped = numbers.groupBy(x => x % 3)
    // {0: [3, 6, 9], 1: [1, 4, 7, 10], 2: [2, 5, 8]}
    
    // flatMap: 扁平化映射
    let nested = ArrayList<ArrayList<Int>>([[1, 2], [3, 4], [5, 6]])
    let flat = nested.flatMap(list => list)
    // [1, 2, 3, 4, 5, 6]
    
    // take: 取前n个元素
    let first3 = numbers.take(3)  // [1, 2, 3]
    
    // drop: 跳过前n个元素
    let rest = numbers.drop(3)  // [4, 5, 6, 7, 8, 9, 10]
    
    // takeWhile: 取元素直到不满足条件
    let taken = numbers.takeWhile(x => x < 5)  // [1, 2, 3, 4]
    
    // dropWhile: 跳过元素直到不满足条件
    let dropped = numbers.dropWhile(x => x < 5)  // [5, 6, 7, 8, 9, 10]
}

3.3 惰性求值

import std.collection.*

func lazyEvaluationDemo() {
    let numbers = ArrayList<Int>([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    
    // 惰性序列：操作不会立即执行
    let lazySeq = numbers
        .asSequence()  // 转为惰性序列
        .filter(x => {
            println("Filter: ${x}")
            return x % 2 == 0
        })
        .map(x => {
            println("Map: ${x}")
            return x * x
        })
    
    println("Before evaluation")
    
    // 终端操作触发求值
    let result = lazySeq.toList()
    
    println("Result: ${result}")
    
    /*
    输出：
    Before evaluation
    Filter: 1
    Filter: 2
    Map: 2
    Filter: 3
    Filter: 4
    Map: 4
    ...
    Result: [4, 16, 36, 64, 100]
    */
}

3.4 生成器

// 生成器：延迟生成序列
func fibonacci(): Sequence<Int> {
    return sequence {
        var a = 0
        var b = 1
        while true {
            yield(a)
            let temp = a
            a = b
            b = temp + b
        }
    }
}

func generatorDemo() {
    // 生成前10个斐波那契数
    let fib10 = fibonacci().take(10).toList()
    println(fib10)  // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
    
    // 无限序列也可以安全处理
    let sum = fibonacci()
        .takeWhile(x => x < 1000)
        .sum()
    
    println("Sum: ${sum}")
}

四、并发编程模型

4.1 线程基础

import std.concurrent.Thread
import std.concurrent.sleep

func threadDemo() {
    // 创建线程方式1：传入函数
    let thread1 = Thread {
        for i in 0..5 {
            println("Thread 1: ${i}")
            sleep(100)  // 休眠100ms
        }
    }
    
    // 创建线程方式2：实现Runnable接口
    class MyTask : Runnable {
        func run() {
            for i in 0..5 {
                println("Thread 2: ${i}")
                sleep(100)
            }
        }
    }
    
    let thread2 = Thread(MyTask())
    
    // 启动线程
    thread1.start()
    thread2.start()
    
    // 等待线程完成
    thread1.join()
    thread2.join()
    
    println("All threads completed")
}

4.2 线程同步：Mutex

import std.concurrent.{Thread, Mutex}

class Counter {
    private var count: Int = 0
    private let mutex = Mutex()
    
    func increment() {
        mutex.lock()
        try {
            count += 1
        } finally {
            mutex.unlock()
        }
    }
    
    // 使用with简化
    func increment2() {
        mutex.with {
            count += 1
        }
    }
    
    func get(): Int {
        return mutex.with {
            return count
        }
    }
}

func mutexDemo() {
    let counter = Counter()
    let threads = ArrayList<Thread>()
    
    // 创建10个线程，每个线程增加1000次
    for i in 0..10 {
        let thread = Thread {
            for j in 0..1000 {
                counter.increment()
            }
        }
        threads.add(thread)
        thread.start()
    }
    
    // 等待所有线程完成
    for thread in threads {
        thread.join()
    }
    
    println("Final count: ${counter.get()}")  // 10000
}

4.3 读写锁：RWLock

import std.concurrent.{Thread, RWLock}

class Cache<K, V> {
    private let data = HashMap<K, V>()
    private let lock = RWLock()
    
    func get(key: K): Option<V> {
        return lock.readLock().with {
            return data.get(key)
        }
    }
    
    func put(key: K, value: V) {
        lock.writeLock().with {
            data.put(key, value)
        }
    }
    
    func size(): Int {
        return lock.readLock().with {
            return data.size()
        }
    }
}

func rwLockDemo() {
    let cache = Cache<String, Int>()
    
    // 写入线程
    let writer = Thread {
        for i in 0..100 {
            cache.put("key${i}", i)
            sleep(10)
        }
    }
    
    // 读取线程
    let readers = (0..5).map { id =>
        Thread {
            for i in 0..100 {
                let value = cache.get("key${i}")
                println("Reader ${id}: ${value}")
                sleep(5)
            }
        }
    }
    
    writer.start()
    for reader in readers {
        reader.start()
    }
    
    writer.join()
    for reader in readers {
        reader.join()
    }
}

4.4 Channel通信

Producer线程 Channel Consumer1线程 Consumer2线程 send(data1) send(data2) send(data3) receive() ->> data1 receive() ->> data2 receive() ->> data3 close() ChannelClosed ChannelClosed 多生产者-多消费者模式 Producer线程 Channel Consumer1线程 Consumer2线程

图5：Channel通信模式 - 线程间安全的消息传递

import std.concurrent.{Thread, Channel}

func channelDemo() {
    // 创建有界Channel（容量10）
    let channel = Channel<Int>(capacity: 10)
    
    // 生产者线程
    let producer = Thread {
        for i in 0..100 {
            channel.send(i)
            println("Produced: ${i}")
        }
        channel.close()  // 关闭Channel
    }
    
    // 消费者线程
    let consumers = (0..3).map { id =>
        Thread {
            while true {
                match channel.receive() {
                    case Some(value) => 
                        println("Consumer ${id} received: ${value}")
                        sleep(10)
                    case None => 
                        println("Consumer ${id} done")
                        break
                }
            }
        }
    }
    
    producer.start()
    for consumer in consumers {
        consumer.start()
    }
    
    producer.join()
    for consumer in consumers {
        consumer.join()
    }
}

// 无界Channel
func unboundedChannelDemo() {
    let channel = Channel<String>()  // 无界
    
    let producer = Thread {
        for i in 0..1000 {
            channel.send("Message ${i}")
        }
        channel.close()
    }
    
    let consumer = Thread {
        for msg in channel {  // 迭代Channel直到关闭
            println(msg)
        }
    }
    
    producer.start()
    consumer.start()
    producer.join()
    consumer.join()
}

4.5 原子操作

import std.concurrent.atomic.{AtomicInt, AtomicBool, AtomicReference}

func atomicDemo() {
    // AtomicInt: 原子整数
    let counter = AtomicInt(0)
    
    let threads = (0..10).map { _ =>
        Thread {
            for i in 0..1000 {
                counter.incrementAndGet()  // 原子递增
            }
        }
    }
    
    for thread in threads {
        thread.start()
    }
    for thread in threads {
        thread.join()
    }
    
    println("Counter: ${counter.get()}")  // 10000
    
    // AtomicBool: 原子布尔
    let flag = AtomicBool(false)
    flag.set(true)
    let old = flag.getAndSet(false)  // 返回true，设置为false
    
    // Compare-And-Swap
    let success = counter.compareAndSet(10000, 0)  // true
    
    // AtomicReference: 原子引用
    let ref = AtomicReference<String>("Hello")
    ref.set("World")
    let oldValue = ref.getAndSet("Cangjie")  // "World"
}

4.6 线程池

import std.concurrent.{ThreadPool, Future}

func threadPoolDemo() {
    // 创建线程池（8个工作线程）
    let pool = ThreadPool(workerCount: 8)
    
    // 提交任务
    let futures = ArrayList<Future<Int>>()
    
    for i in 0..100 {
        let future = pool.submit {
            // 模拟耗时任务
            sleep(100)
            return i * i
        }
        futures.add(future)
    }
    
    // 获取结果
    let results = futures.map(f => f.get())
    println("Results: ${results}")
    
    // 关闭线程池
    pool.shutdown()
    pool.awaitTermination()
}

五、异步编程与协程

5.1 协程基础

import std.async.{async, await, Coroutine}

// async函数返回Future
async func fetchUser(id: Int): User {
    // 模拟网络请求
    await sleep(1000)
    return User(id, "User${id}")
}

async func fetchUserPosts(userId: Int): ArrayList<Post> {
    await sleep(500)
    return ArrayList<Post>([
        Post(1, "Post 1"),
        Post(2, "Post 2")
    ])
}

// 并发执行多个异步任务
async func getUserProfile(id: Int): UserProfile {
    // 并发获取用户和帖子
    let userFuture = fetchUser(id)
    let postsFuture = fetchUserPosts(id)
    
    let user = await userFuture
    let posts = await postsFuture
    
    return UserProfile(user, posts)
}

func asyncDemo() {
    // 启动协程
    let coroutine = Coroutine {
        let profile = await getUserProfile(123)
        println("User: ${profile.user.name}")
        println("Posts: ${profile.posts.size()}")
    }
    
    coroutine.start()
    coroutine.join()  // 等待完成
}

5.2 协程调度流程
是
否
是
否
是
否
协程创建
Ready队列
调度器选择
分配到线程
执行中
遇到await?
挂起保存状态
执行完成?
等待IO/计时器
条件满足?
协程完成

图6：协程调度流程 - 轻量级任务的挂起与恢复机制

5.3 异步IO

import std.async.{async, await}
import std.io.{File, FileMode}
import std.net.{HTTP, HTTPClient}

// 异步文件读取
async func readFileAsync(path: String): String {
    let file = File.open(path, FileMode.Read)
    defer { file.close() }
    
    return await file.readToStringAsync()
}

// 异步HTTP请求
async func fetchData(url: String): String {
    let client = HTTPClient()
    let response = await client.get(url)
    return response.body
}

// 并发处理多个文件
async func processFiles(paths: ArrayList<String>) {
    let futures = paths.map { path =>
        async {
            let content = await readFileAsync(path)
            return content.length
        }
    }
    
    // 等待所有文件处理完成
    let sizes = await Future.all(futures)
    println("Total size: ${sizes.sum()}")
}

5.4 协程取消与超时

import std.async.{async, await, timeout, withTimeout, CancellationToken}

async func longRunningTask(token: CancellationToken): Int {
    for i in 0..1000 {
        // 检查是否被取消
        if token.isCancelled() {
            throw CancellationException()
        }
        
        await sleep(10)
        println("Progress: ${i}")
    }
    return 1000
}

func cancellationDemo() {
    let token = CancellationToken()
    
    let coroutine = Coroutine {
        try {
            let result = await longRunningTask(token)
            println("Completed: ${result}")
        } catch (e: CancellationException) {
            println("Task cancelled")
        }
    }
    
    coroutine.start()
    
    // 3秒后取消
    sleep(3000)
    token.cancel()
    
    coroutine.join()
}

// 超时控制
async func timeoutDemo() {
    try {
        // 最多等待2秒
        let result = await withTimeout(2000) {
            await longRunningTask(CancellationToken())
        }
        println("Result: ${result}")
    } catch (e: TimeoutException) {
        println("Operation timed out")
    }
}

5.5 协程作用域

import std.async.{CoroutineScope, launch, async}

func coroutineScopeDemo() {
    let scope = CoroutineScope()
    
    // 在作用域内启动多个协程
    scope.launch {
        await sleep(1000)
        println("Task 1 completed")
    }
    
    scope.launch {
        await sleep(500)
        println("Task 2 completed")
    }
    
    let future = scope.async {
        await sleep(1500)
        return 42
    }
    
    // 等待作用域内所有协程完成
    scope.join()
    
    println("Result: ${future.get()}")
    
    // 取消作用域（取消所有协程）
    // scope.cancel()
}

六、错误处理与资源管理

6.1 Result类型与错误传播

import std.result.{Result, Ok, Err}

// 定义自定义错误
enum FileError {
    NotFound(path: String)
    PermissionDenied(path: String)
    IOError(message: String)
}

// 返回Result的函数
func readConfig(path: String): Result<Config, FileError> {
    if !File.exists(path) {
        return Err(FileError.NotFound(path))
    }
    
    try {
        let content = File.readToString(path)
        let config = parseConfig(content)
        return Ok(config)
    } catch (e: IOException) {
        return Err(FileError.IOError(e.message))
    }
}

// 使用?操作符传播错误
func loadUserConfig(userId: Int): Result<UserConfig, FileError> {
    let configPath = "/config/user_${userId}.json"
    let config = readConfig(configPath)?  // 错误自动传播
    
    let userData = parseUserData(config)?
    return Ok(UserConfig(userData))
}

// 错误处理
func errorHandlingDemo() {
    match loadUserConfig(123) {
        case Ok(config) => {
            println("Config loaded: ${config}")
        }
        case Err(FileError.NotFound(path)) => {
            println("Config file not found: ${path}")
        }
        case Err(FileError.PermissionDenied(path)) => {
            println("Permission denied: ${path}")
        }
        case Err(FileError.IOError(msg)) => {
            println("IO error: ${msg}")
        }
    }
}

6.2 资源管理：defer与RAII

import std.io.{File, FileMode}

// 使用defer确保资源释放
func deferDemo() {
    let file = File.open("data.txt", FileMode.Read)
    defer { file.close() }  // 函数返回前自动执行
    
    let content = file.readToString()
    println(content)
    
    // 即使发生异常，defer也会执行
}

// RAII模式：自动资源管理
class ManagedFile : Closeable {
    private let file: File
    
    init(path: String, mode: FileMode) {
        this.file = File.open(path, mode)
    }
    
    func read(): String {
        return file.readToString()
    }
    
    func close() {
        file.close()
        println("File closed")
    }
}

// 使用use函数自动管理
func useDemo() {
    ManagedFile("data.txt", FileMode.Read).use { file =>
        let content = file.read()
        println(content)
    }  // 自动调用close()
}

6.3 异常处理最佳实践

// 自定义异常
class ValidationException(message: String) : Exception(message)

func validateAge(age: Int): Result<Int, ValidationException> {
    if age < 0 {
        return Err(ValidationException("Age cannot be negative"))
    }
    if age > 150 {
        return Err(ValidationException("Age too large"))
    }
    return Ok(age)
}

// 组合多个Result
func createUser(name: String, age: Int): Result<User, Exception> {
    let validName = validateName(name)?
    let validAge = validateAge(age)?
    
    return Ok(User(validName, validAge))
}

七、IO与文件操作

7.1 文件读写

import std.io.{File, FileMode, Path}

func fileIODemo() {
    // 读取文件
    let content = File.readToString("input.txt")
    println(content)
    
    // 写入文件
    File.writeString("output.txt", "Hello, Cangjie!")
    
    // 追加内容
    File.appendString("output.txt", "\nNew line")
    
    // 按行读取
    let lines = File.readLines("input.txt")
    for line in lines {
        println(line)
    }
    
    // 使用Reader/Writer
    let reader = File.open("input.txt", FileMode.Read).reader()
    defer { reader.close() }
    
    let writer = File.open("output.txt", FileMode.Write).writer()
    defer { writer.close() }
    
    var line = ""
    while (line = reader.readLine()) != None {
        writer.writeLine(line!)
    }
}

7.2 路径操作

import std.io.Path

func pathDemo() {
    let path = Path("/home/user/documents/file.txt")
    
    println(path.name)  // "file.txt"
    println(path.parent)  // "/home/user/documents"
    println(path.extension)  // "txt"
    println(path.stem)  // "file"
    
    // 路径拼接
    let newPath = path.parent.join("newfile.txt")
    println(newPath)  // "/home/user/documents/newfile.txt"
    
    // 路径判断
    println(path.exists())
    println(path.isFile())
    println(path.isDirectory())
    
    // 创建目录
    let dir = Path("/tmp/myapp")
    dir.createDir()  // 创建单级目录
    dir.createDirs()  // 创建多级目录
    
    // 列出目录内容
    for entry in dir.list() {
        println("${entry.name}: ${if entry.isFile() "File" else "Dir"}")
    }
    
    // 递归遍历
    for entry in dir.walk() {
        println(entry.path)
    }
}

7.3 JSON序列化

import std.encoding.JSON

// 定义数据类
@Serializable
class Person {
    let name: String
    let age: Int
    let email: String
    
    init(name: String, age: Int, email: String) {
        this.name = name
        this.age = age
        this.email = email
    }
}

func jsonDemo() {
    let person = Person("Alice", 25, "alice@example.com")
    
    // 序列化为JSON
    let json = JSON.stringify(person)
    println(json)
    // {"name":"Alice","age":25,"email":"alice@example.com"}
    
    // 反序列化
    let parsed = JSON.parse<Person>(json)
    println(parsed.name)  // "Alice"
    
    // 处理复杂结构
    let people = ArrayList<Person>([
        Person("Alice", 25, "alice@example.com"),
        Person("Bob", 30, "bob@example.com")
    ])
    
    let jsonArray = JSON.stringify(people)
    let parsedArray = JSON.parse<ArrayList<Person>>(jsonArray)
}

八、标准库源码剖析

8.1 ArrayList实现原理

// 简化的ArrayList实现
class SimpleArrayList<T> {
    private var data: Array<Option<T>>
    private var size_: Int = 0
    private var capacity_: Int
    
    init(capacity: Int = 10) {
        this.capacity_ = capacity
        this.data = Array<Option<T>>(capacity, None)
    }
    
    func add(element: T) {
        if size_ >= capacity_ {
            resize()  // 扩容
        }
        data[size_] = Some(element)
        size_ += 1
    }
    
    func get(index: Int): T {
        if index < 0 || index >= size_ {
            throw IndexOutOfBoundsException()
        }
        return data[index]!
    }
    
    // 扩容策略：容量翻倍
    private func resize() {
        let newCapacity = capacity_ * 2
        let newData = Array<Option<T>>(newCapacity, None)
        
        for i in 0..size_ {
            newData[i] = data[i]
        }
        
        data = newData
        capacity_ = newCapacity
    }
    
    func size(): Int {
        return size_
    }
}

扩容性能分析：

操作次数 扩容次数 总复制次数 均摊成本
1 0 0 O(1)
10 0 0 O(1)
11 1 10 O(1)
21 2 30 O(1)
100 4 150 O(1)

结论：扩容虽然是O(n)操作，但均摊复杂度为O(1)。

8.2 HashMap实现原理

// 简化的HashMap实现
class SimpleHashMap<K, V> where K: Hashable {
    private class Entry<K, V> {
        let key: K
        var value: V
        var next: Option<Entry<K, V>> = None
        
        init(key: K, value: V) {
            this.key = key
            this.value = value
        }
    }
    
    private var buckets: Array<Option<Entry<K, V>>>
    private var size_: Int = 0
    private var capacity_: Int
    private let loadFactor: Float = 0.75
    
    init(capacity: Int = 16) {
        this.capacity_ = capacity
        this.buckets = Array<Option<Entry<K, V>>>(capacity, None)
    }
    
    func put(key: K, value: V): Option<V> {
        let index = hash(key) % capacity_
        
        // 查找key是否已存在
        var current = buckets[index]
        while current != None {
            let entry = current!
            if entry.key == key {
                let oldValue = entry.value
                entry.value = value
                return Some(oldValue)
            }
            current = entry.next
        }
        
        // 插入新节点（头插法）
        let newEntry = Entry(key, value)
        newEntry.next = buckets[index]
        buckets[index] = Some(newEntry)
        size_ += 1
        
        // 检查是否需要扩容
        if size_ > capacity_ * loadFactor {
            resize()
        }
        
        return None
    }
    
    func get(key: K): Option<V> {
        let index = hash(key) % capacity_
        var current = buckets[index]
        
        while current != None {
            let entry = current!
            if entry.key == key {
                return Some(entry.value)
            }
            current = entry.next
        }
        
        return None
    }
    
    private func hash(key: K): Int {
        return key.hashCode() & 0x7FFFFFFF  // 确保非负
    }
    
    private func resize() {
        let oldBuckets = buckets
        capacity_ *= 2
        buckets = Array<Option<Entry<K, V>>>(capacity_, None)
        size_ = 0
        
        // 重新哈希所有元素
        for bucket in oldBuckets {
            var current = bucket
            while current != None {
                let entry = current!
                put(entry.key, entry.value)
                current = entry.next
            }
        }
    }
}

九、性能优化实战

9.1 集合选择优化

import std.time.{Instant, Duration}

// 性能测试框架
func benchmark(name: String, iterations: Int, fn: () -> Unit) {
    let start = Instant.now()
    
    for i in 0..iterations {
        fn()
    }
    
    let end = Instant.now()
    let duration = Duration.between(start, end)
    
    println("${name}: ${duration.toMillis()}ms")
}

func collectionBenchmark() {
    let n = 100000
    
    // ArrayList vs LinkedList: 随机访问
    benchmark("ArrayList random access", 10000) {
        let list = ArrayList<Int>()
        for i in 0..n {
            list.add(i)
        }
        var sum = 0
        for i in 0..1000 {
            sum += list[Random.nextInt(n)]
        }
    }
    
    benchmark("LinkedList random access", 10000) {
        let list = LinkedList<Int>()
        for i in 0..n {
            list.add(i)
        }
        var sum = 0
        for i in 0..1000 {
            sum += list.get(Random.nextInt(n))
        }
    }
    
    // ArrayList vs LinkedList: 顺序插入
    benchmark("ArrayList sequential insert", 1000) {
        let list = ArrayList<Int>()
        for i in 0..n {
            list.add(i)
        }
    }
    
    benchmark("LinkedList sequential insert", 1000) {
        let list = LinkedList<Int>()
        for i in 0..n {
            list.add(i)
        }
    }
}

9.2 避免不必要的拷贝

// 不好的做法：多次拷贝
func processData1(data: ArrayList<Int>): ArrayList<Int> {
    var result = ArrayList<Int>()
    
    for item in data {
        if item > 0 {
            result.add(item)
        }
    }
    
    // 又一次拷贝
    let sorted = result.sorted()
    return sorted
}

// 好的做法：原地操作
func processData2(data: ArrayList<Int>): ArrayList<Int> {
    // 使用filter避免手动循环
    return data
        .filter(x => x > 0)
        .sorted()
}

// 更好的做法：使用Sequence避免中间集合
func processData3(data: ArrayList<Int>): ArrayList<Int> {
    return data
        .asSequence()
        .filter(x => x > 0)
        .sorted()
        .toList()
}

9.3 并发优化

import std.concurrent.{ThreadPool, Future}

// 串行处理
func processSerial(data: ArrayList<Data>): ArrayList<Result> {
    return data.map { item =>
        processItem(item)  // 耗时操作
    }
}

// 并行处理
func processParallel(data: ArrayList<Data>): ArrayList<Result> {
    let pool = ThreadPool(8)
    
    let futures = data.map { item =>
        pool.submit {
            processItem(item)
        }
    }
    
    let results = futures.map(f => f.get())
    pool.shutdown()
    
    return results
}

// 性能对比
func concurrencyBenchmark() {
    let data = generateTestData(1000)
    
    benchmark("Serial", 1) {
        processSerial(data)
    }
    
    benchmark("Parallel (8 threads)", 1) {
        processParallel(data)
    }
}

9.4 内存优化

// 不好：创建大量临时对象
func concat1(strings: ArrayList<String>): String {
    var result = ""
    for s in strings {
        result += s  // 每次都创建新字符串
    }
    return result
}

// 好：使用StringBuilder
func concat2(strings: ArrayList<String>): String {
    let sb = StringBuilder()
    for s in strings {
        sb.append(s)
    }
    return sb.toString()
}

// 更好：使用join
func concat3(strings: ArrayList<String>): String {
    return strings.join("")
}

9.5 性能对比图表

性能对比图

图7：集合操作性能对比 - ArrayList vs LinkedList vs HashSet vs HashMap 全方位性能分析

性能数据总结：

操作 ArrayList LinkedList HashSet HashMap
随机访问 O(1) ⚡ O(n) 🐌 N/A O(1) ⚡
顺序遍历 O(n) ⚡ O(n) ⚡ O(n) ⚡ O(n) ⚡
头部插入 O(n) 🐌 O(1) ⚡ O(1) ⚡ O(1) ⚡
尾部插入 O(1)* ⚡ O(1) ⚡ O(1) ⚡ O(1) ⚡
查找元素 O(n) 🐌 O(n) 🐌 O(1) ⚡ O(1) ⚡
删除元素 O(n) 🐌 O(n) 🐌 O(1) ⚡ O(1) ⚡

十、鸿蒙应用实战案例

10.1 实战：高性能图片加载器

import std.collection.{HashMap, LRUCache}
import std.concurrent.{ThreadPool, RWLock}
import std.async.{async, await}
import harmoneos.ui.Image

// LRU缓存实现
class ImageCache {
    private let cache = LRUCache<String, Image>(capacity: 100)
    private let lock = RWLock()
    private let pool = ThreadPool(4)
    
    async func loadImage(url: String): Image {
        // 先查缓存
        let cached = lock.readLock().with {
            cache.get(url)
        }
        
        if cached != None {
            return cached!
        }
        
        // 异步下载
        let image = await downloadImage(url)
        
        // 写入缓存
        lock.writeLock().with {
            cache.put(url, image)
        }
        
        return image
    }
    
    async func preloadImages(urls: ArrayList<String>) {
        let futures = urls.map { url =>
            pool.submit {
                await loadImage(url)
            }
        }
        
        await Future.all(futures)
    }
    
    private async func downloadImage(url: String): Image {
        // 实际的网络请求
        let httpClient = HTTPClient()
        let response = await httpClient.get(url)
        return Image.decode(response.body)
    }
}

10.2 实战：线程安全的日志系统

import std.collection.{Queue, ArrayList}
import std.concurrent.{Thread, Mutex, Channel}
import std.io.{File, FileMode}

enum LogLevel {
    Debug
    Info
    Warning
    Error
}

class Logger {
    private let channel = Channel<LogEntry>(capacity: 1000)
    private let writerThread: Thread
    private let file: File
    
    init(logFile: String) {
        this.file = File.open(logFile, FileMode.Append)
        this.writerThread = Thread {
            this.processLogs()
        }
        this.writerThread.start()
    }
    
    func log(level: LogLevel, message: String) {
        let entry = LogEntry(
            level: level,
            message: message,
            timestamp: DateTime.now()
        )
        channel.send(entry)
    }
    
    func debug(message: String) {
        log(LogLevel.Debug, message)
    }
    
    func info(message: String) {
        log(LogLevel.Info, message)
    }
    
    func error(message: String) {
        log(LogLevel.Error, message)
    }
    
    private func processLogs() {
        for entry in channel {
            let formatted = formatLogEntry(entry)
            file.writeLine(formatted)
            file.flush()
        }
    }
    
    private func formatLogEntry(entry: LogEntry): String {
        return "[${entry.timestamp}] [${entry.level}] ${entry.message}"
    }
    
    func close() {
        channel.close()
        writerThread.join()
        file.close()
    }
}

// 使用示例
func loggerDemo() {
    let logger = Logger("/var/log/myapp.log")
    defer { logger.close() }
    
    logger.info("Application started")
    logger.debug("Processing user request")
    logger.error("Database connection failed")
}

10.3 实战：响应式数据流

import std.collection.ArrayList
import std.concurrent.{Thread, Channel}

// 简单的Observable实现
class Observable<T> {
    private let observers = ArrayList<(T) -> Unit>()
    
    func subscribe(observer: (T) -> Unit) {
        observers.add(observer)
    }
    
    func emit(value: T) {
        for observer in observers {
            observer(value)
        }
    }
    
    func map<R>(transform: (T) -> R): Observable<R> {
        let mapped = Observable<R>()
        this.subscribe { value =>
            mapped.emit(transform(value))
        }
        return mapped
    }
    
    func filter(predicate: (T) -> Bool): Observable<T> {
        let filtered = Observable<T>()
        this.subscribe { value =>
            if predicate(value) {
                filtered.emit(value)
            }
        }
        return filtered
    }
}

// 使用示例：实时数据流
func observableDemo() {
    let dataStream = Observable<Int>()
    
    // 创建多个订阅者
    dataStream
        .filter(x => x > 0)
        .map(x => x * 2)
        .subscribe { value =>
            println("Subscriber 1: ${value}")
        }
    
    dataStream
        .filter(x => x % 2 == 0)
        .subscribe { value =>
            println("Subscriber 2: ${value}")
        }
    
    // 发送数据
    for i in -5..5 {
        dataStream.emit(i)
    }
}

十一、总结与最佳实践

11.1 核心要点

1. 集合选择：

  • ✅ 需要快速随机访问 → ArrayList
  • ✅ 频繁插入删除 → LinkedList
  • ✅ 需要唯一性 → HashSet
  • ✅ 键值映射 → HashMap

2. 并发编程：

  • ✅ 使用Mutex保护共享状态
  • ✅ 优先使用Channel进行线程间通信
  • ✅ 使用线程池管理工作线程
  • ✅ 优先使用不可变数据结构

3. 异步编程：

  • ✅ 使用async/await处理IO操作
  • ✅ 并发执行独立任务提升性能
  • ✅ 合理使用协程避免线程开销

4. 性能优化：

  • ✅ 避免不必要的集合拷贝
  • ✅ 使用StringBuilder拼接字符串
  • ✅ 使用惰性序列处理大数据
  • ✅ 预分配集合容量避免扩容

11.2 学习路径
标准库入门
集合框架
迭代器与函数式
并发编程
异步编程
性能优化
实战项目
ArrayList/HashMap
map/filter/reduce
Mutex/Channel
async/await
性能分析
鸿蒙应用

图8：仓颉标准库学习路径 - 从基础到实战的完整路线

11.3 参考资源

🔗 系列文章

  • 《仓颉语言实战：从零开发鸿蒙原生应用》
  • 《仓颉语言核心特性深度解析：类型系统与内存安全实践》
  • 《仓颉语言标准库深度解析：集合框架与并发编程实战》（本文）

💡 写在最后：仓颉标准库提供了丰富而强大的基础设施，从集合框架到并发编程，从异步IO到函数式API，涵盖了现代应用开发的方方面面。深入理解标准库的设计理念和最佳实践，是成为仓颉语言专家的必经之路。希望本文能帮助你快速掌握标准库的核心内容！

🎯 下一步：建议结合前两篇系列文章，将标准库知识应用到实际的鸿蒙应用开发中，通过实战项目加深理解。

💡 如果本文对你有帮助，欢迎点赞👍、收藏⭐、关注➕，你的支持是我创作的最大动力！

📚 鸿蒙学习推荐：我正在参与华为官方组织的鸿蒙培训课程，课程内容涵盖HarmonyOS应用开发、分布式能力、ArkTS开发等核心技术。如果你也对鸿蒙开发感兴趣，欢迎加入我的班级一起学习：

🔗 点击进入鸿蒙培训班级

#仓颉语言 #鸿蒙开发 #标准库 #集合框架 #并发编程 #异步编程 #性能优化

# harmonyos # 分布式 # wpf
Logo
人工智能6S服务平台

作为“人工智能6S店”的官方数字引擎，为AI开发者与企业提供一个覆盖软硬件全栈、一站式门户。

更多推荐

cover

鸿蒙原生ArkTS布局方式之ColumnCenter垂直排列

avatar 人工智能6S服务平台

VeRL× 昇腾NPU：GRPO 强化训练全链路实战

是字节跳动 Seed 团队发起、社区共同维护的 LLM 强化学习（RL/RLHF）训练框架。是论文的开源实现版本。框架特点：算法侧：支持 GRPO、PPO 等 RL 数据流/训练循环的搭建。工程侧：通过模块化 API 对接既有 LLM infra（如 FSDP、Megatron-LM、vLLM、SGLang 等）。多机多卡资源编排：官方的多机示例采用 Ray 集群方式启动 head/worker。

avatar 人工智能6S服务平台

【鸿蒙NEXT开发】ArkUI实现极简文件管理器

本文介绍了一个基于HarmonyOS NEXT API20+和ArkTS原生语法开发的完整文件管理器项目。项目实现了目录导航、文件多选、增删改操作、多维度排序等核心功能，采用纯原生ArkUI开发，适配最新API20语法规范。 文章重点分析了API20不兼容导致的典型报错（Select组件fontSize属性和Row组件onLongClick事件废弃），并提供了修复方案。通过定义FileItem接口

avatar 人工智能6S服务平台