在基础数据类型一篇我们了解了仓颉数组类型，用来表示单一类型的元素构成的有序序列。使用 Array<T> 来表示 Array 类型。T 表示 Array 的元素类型，T 可以是任意类型。

public struct Array<T> {
    public const init()
    public init(size: Int64, repeat!: T)
    public init(size: Int64, initElement: (Int64) -> T)
}

由于Array是结构体类型，所以被定义的数组，不能增删，只能修改，适合不需要增加和删除元素，但需要修改元素的场景。

Collection (不支持并发安全)

collection 包提供了常见数据结构的高效实现、相关抽象的接口的定义以及在集合类型中常用的函数功能。以下常用的数据结构：

ArrayList<T>

ArrayList 是一种线性的动态数组，与 Array 不同，它可以根据需要自动调整大小，并且在创建时不需要指定大小。

public class ArrayList<T> <: List<T> {
    public init()
    public init(capacity: Int64)
    public init(size: Int64, initElement: (Int64) -> T)
    public init(elements: Collection<T>)
}

import std.collection.*
main() {
    var array = ArrayList<Int64>()
    println(array.size)   // 元素个数:0 
    println(array.capacity) //容量:16
    for (i in 0..16) {
        array.add(i)     //添加0-15
    }
    println(array.size)   // 元素个数:16 
    println(array.capacity) //容量:16
    for (i in 16..32) {
        array.add(i)    //添加16-31
    } 
    println(array.size)   // 元素个数:32 
    println(array.capacity) //容量:36
    array.remove(0..10)    //删除下标 0-9 的元素
    println(array.size)   // 元素个数:22 
    println(array.capacity) //容量:36
    array.clear()         //清空 
    println(array.size)   // 元素个数:0
    println(array.capacity) //容量:36
    var a = ArrayList.of(array)
    println(a.toString())
}

HashMap<K, V>

哈希表是一种常用的数据结构，它可以用来快速地查找、插入和删除数据。哈希表的基本原理是将数据映射到一个数组中，这个数组称为哈希表。每个数据元素都有一个对应的哈希值，这个哈希值可以用来确定该元素在哈希表中的位置。
哈希表的特点是快速的查找、插入和删除操作，时间复杂度通常是O(1)。由于哈希表底层的数组大小是动态的，所以哈希表不能保证元素的顺序不可变。

public class HashMap<K, V> <: Map<K, V> where K <: Hashable & Equatable<K> {
    public init()
    public init(elements: Array<(K, V)>)
    public init(elements: Collection<(K, V)>)
    public init(capacity: Int64)
    public init(size: Int64, initElement: (Int64) -> (K, V))
}

import std.collection.*
main() {
    var a = HashMap<String, Int64>()
    println('初始size:${a.size}')   // 0 
    println('初始容量:${a.capacity}') // 16
    a.add('语文',90)
    a.add('数学',93)
    a.add('英语',96)
    a.add('历史',94)
    println(a.keys().toArray()) //[语文, 数学, 英语, 历史]
    println('语文:${a.get('语文')}') //Some(90)
    a.addIfAbsent('语文',99)     
    println('语文:${a.get('语文')}')  //Some(90)
    println(a.values().toArray())  //[90, 93, 96, 94]
    a.replace('地理', 100)
    println(a.contains('地理')) //false
    a.removeIf({k,v=>v>90})    //删除 满足 值>90  的键值对
    println(a.keys().toArray()) // [语文]
    a['语文']=100
    println(a['语文'])  //100
} 

HashSet

使用 HashSet 类型来构造只拥有不重复元素的 Collection。它可以用于快速检索和删除元素，具有高效的插入、删除和查找操作。

public class HashSet<T> <: Set<T> where T <: Hashable & Equatable<T> {
    public init()
    public init(elements: Collection<T>)
    public init(elements: Array<T>)
    public init(capacity: Int64)
    public init(size: Int64, initElement: (Int64) -> T)
}

import std.collection.*
main() {
    var a = HashSet<Int64>()
    println('初始size:${a.size}')   // 0 
    println('初始容量:${a.capacity}') // 16
    a.add(all:[1,3,5,7])
    println(a) //[1, 3, 5, 7]
    var b = a.clone()
    b.add(2)
    b.add(4)
    b.add(6)
    println(a.toArray()) //[1, 3, 5, 7]
    println(b.toArray()) //[1, 3, 5, 7, 2, 4, 6]
    println(b.contains(all:a)) //true
    println(a&b)  //[1, 3, 5, 7]
    println(b-a) //[2, 4, 6]
    println(a|b) //[1, 3, 5, 7, 2, 4, 6]
    b.removeIf({v=>v%2==0})  // 删除b中的偶数
    println(b)  //[1, 3, 5, 7]
} 

Iterable<E>

该接口表示可迭代，实现了该接口的类型（通常为容器类型）可以在 for-in 语句中实现迭代，也可以获取其对应的迭代器类型实例，调用 next 函数实现迭代。

public interface Iterable<E> {
    func iterator(): Iterator<E>
}

Array、ArrayList、HashSet、HashMap 类型都实现了 Iterable，因此可以将其用在 for-in 或者 while 中。

import std.collection.*
main() {
    var a = ArrayList<Int64>([1,3,5,7,9])
    for (i in a) {
        print(i) // 13579
    }
    println()
    var it = a.iterator()
    while (true) {
        match (it.next()) {
        case Some(i) => print(i)  //13579
        case None => break
        }
    }
    println()
    var it2=a.iterator()
    while (let Some(i) <- it2.next()) {
        print(i)  //13579
    }
} 

collection.concurrent (并发安全)

本包实现了以下几种并发安全的集合类型