仓颉开发语言中的基础 Collection 类型概述

在仓颉开发语言中，基础 Collection 类型是我们进行数据存储和操作的重要工具。理解这些类型的特性和使用场景可以帮助我们在开发中更高效地选择合适的数据结构。本篇博文将介绍仓颉中常用的几种基础 Collection 类型，包括 Array、ArrayList、HashSet 和 HashMap。

Array

Array 是最基础的集合类型之一。当我们需要一个固定大小且元素类型相同的集合，并且不需要频繁地增加或删除元素时，Array 是一个非常合适的选择。Array 支持元素的修改，但不支持动态扩展或收缩。

var arr: Array<Int64> = [1, 2, 3]
arr[0] = 10

ArrayList

ArrayList 是一个动态数组，支持频繁的增删改查操作。它具有很好的扩容能力，适用于需要动态管理元素的场景。相比 Array，ArrayList 不仅可以修改元素，还可以动态地增加和删除元素。

导入 collection 包并使用 ArrayList 类型：

import std.collection.*

var list: ArrayList<Int64> = ArrayList<Int64>([1, 2, 3])
list.append(4) // list 现在包含元素 1, 2, 3, 4
list.remove(1) // 删除索引为 1 的元素，list 现在包含元素 1, 3, 4

HashSet

HashSet 是一个无序且不允许重复元素的集合类型。它适用于需要确保集合中没有重复元素的场景。HashSet 使用哈希表实现，因此其查找和插入操作通常具有较好的性能。

导入 collection 包并使用 HashSet 类型：

import std.collection.*

var set: HashSet<Int64> = HashSet<Int64>([1, 2, 3])
set.put(4) // set 现在包含元素 1, 2, 3, 4
set.put(2) // set 仍然包含元素 1, 2, 3, 4，因为元素 2 已经存在

HashMap

HashMap 是一个键值对（key-value pair）集合类型，适用于需要通过键来快速查找值的场景。键必须是唯一的，值则可以是任何类型。HashMap 使用哈希表实现，通常具有较高的查找和插入性能。

导入 collection 包并使用 HashMap 类型：

import std.collection.*

var map: HashMap<String, Int64> = HashMap<String, Int64>()
map.put("one", 1) // 添加键值对 ("one", 1)
map.put("two", 2) // 添加键值对 ("two", 2)
var value = map["one"] // 获取键 "one" 对应的值，value == 1

基础 Collection 类型特性总结

通过以上表格和实例代码，我们可以清楚地看到各种 Collection 类型的特性和适用场景。在实际开发中，根据业务需求选择合适的 Collection 类型，能够提高程序的性能和可维护性。希望这篇博文能够帮助你更好地理解和使用仓颉开发语言中的基础 Collection 类型。

深入 ArrayList

ArrayList 在仓颉语言中是一个非常强大的数据结构，它不仅支持动态扩展，还提供了丰富的操作方法。下面我们将更详细地介绍 ArrayList 的一些高级用法和性能优化技巧。

创建 ArrayList

我们可以通过多种方式创建 ArrayList，例如使用构造函数创建空的 ArrayList 或包含初始元素的 ArrayList。

import std.collection.*

// 创建一个空的 ArrayList
var emptyList: ArrayList<Int64> = ArrayList<Int64>()

// 创建一个包含初始元素的 ArrayList
var listWithElements: ArrayList<Int64> = ArrayList<Int64>([1, 2, 3])

// 使用另一个集合初始化 ArrayList
var anotherList: ArrayList<Int64> = ArrayList<Int64>(listWithElements)

访问和修改 ArrayList 元素

我们可以通过下标访问和修改 ArrayList 的元素，也可以使用 for-in 循环遍历所有元素。

import std.collection.*

var list: ArrayList<Int64> = ArrayList<Int64>([1, 2, 3])

// 访问元素
var firstElement = list[0] // firstElement == 1

// 修改元素
list[0] = 10 // list 现在包含元素 10, 2, 3

// 遍历元素
for (element in list) {
    println("The element is ${element}")
}

增加和删除元素

ArrayList 提供了多种方法来增加和删除元素，例如 append、appendAll、insert、insertAll 和 remove。

import std.collection.*

var list: ArrayList<Int64> = ArrayList<Int64>([1, 2, 3])

// 添加单个元素
list.append(4) // list 现在包含元素 1, 2, 3, 4

// 添加多个元素
var additionalElements = [5, 6]
list.appendAll(additionalElements) // list 现在包含元素 1, 2, 3, 4, 5, 6

// 插入单个元素
list.insert(2, 10) // 在索引 2 处插入元素 10，list 现在包含元素 1, 2, 10, 3, 4, 5, 6

// 删除元素
list.remove(1) // 删除索引为 1 的元素，list 现在包含元素 1, 10, 3, 4, 5, 6

ArrayList 性能优化

当我们知道大约需要添加多少个元素时，可以在添加之前预留足够的内存以避免频繁的内存重新分配，这样可以提升性能表现。

import std.collection.*

var list: ArrayList<Int64> = ArrayList<Int64>()

// 预留空间以避免频繁重新分配
list.reserve(100) // 预留 100 个元素的空间

for (i in 0..99) {
    list.append(i) // 不会触发重新分配内存
}

深入 HashSet

HashSet 是一种集合类型，它确保集合中的每个元素都是唯一的。我们将介绍一些 HashSet 的高级用法。

创建 HashSet

我们可以通过多种方式创建 HashSet，例如使用构造函数创建空的 HashSet 或包含初始元素的 HashSet。

import std.collection.*

// 创建一个空的 HashSet
var emptySet: HashSet<Int64> = HashSet<Int64>()

// 创建一个包含初始元素的 HashSet
var setWithElements: HashSet<Int64> = HashSet<Int64>([1, 2, 3])

// 使用另一个集合初始化 HashSet
var anotherSet: HashSet<Int64> = HashSet<Int64>(setWithElements)

访问 HashSet 元素

我们可以使用 contains 方法来检查 HashSet 是否包含某个元素。

import std.collection.*

var set: HashSet<Int64> = HashSet<Int64>([1, 2, 3])

var containsOne = set.contains(1) // containsOne == true
var containsFour = set.contains(4) // containsFour == false

修改 HashSet

我们可以使用 put 方法添加元素，使用 remove 方法删除元素。HashSet 会自动确保每个元素的唯一性。

import std.collection.*

var set: HashSet<Int64> = HashSet<Int64>([1, 2, 3])

// 添加元素
set.put(4) // set 现在包含元素 1, 2, 3, 4
set.put(2) // set 仍然包含元素 1, 2, 3, 4，因为元素 2 已经存在

// 删除元素
set.remove(1) // set 现在包含元素 2, 3, 4

深入 HashMap

HashMap 是一种键值对（key-value pair）集合类型，它允许通过键来快速查找值。我们将介绍一些 HashMap 的高级用法。

创建 HashMap

我们可以通过多种方式创建 HashMap，例如使用构造函数创建空的 HashMap 或包含初始键值对的 HashMap。

import std.collection.*

// 创建一个空的 HashMap
var emptyMap: HashMap<String, Int64> = HashMap<String, Int64>()

// 创建一个包含初始键值对的 HashMap
var mapWithElements: HashMap<String, Int64> = HashMap<String, Int64>()
mapWithElements.put("one", 1)
mapWithElements.put("two", 2)

// 使用另一个集合初始化 HashMap
var anotherMap: HashMap<String, Int64> = HashMap<String, Int64>(mapWithElements)

访问和修改 HashMap 元素

我们可以通过键来访问和修改 HashMap 的元素。

import std.collection.*

var map: HashMap<String, Int64> = HashMap<String, Int64>()
map.put("one", 1)
map.put("two", 2)

// 访问元素
var valueOne = map["one"] // valueOne == 1

// 修改元素
map["one"] = 10 // map 现在包含键值对 ("one", 10) 和 ("two", 2)

遍历 HashMap

我们可以使用 for-in 循环遍历 HashMap 的所有键值对。

import std.collection.*

var map: HashMap<String, Int64> = HashMap<String, Int64>()
map.put("one", 1)
map.put("two", 2)

for ((key, value) in map) {
    println("The key is ${key} and the value is ${value}")
}

HashMap 性能优化

当我们知道大约需要存储多少个键值对时，可以在添加之前预留足够的内存以避免频繁的内存重新分配，这样可以提升性能表现。

import std.collection.*

var map: HashMap<String, Int64> = HashMap<String, Int64>()

// 预留空间以避免频繁重新分配
map.reserve(100) // 预留 100 个键值对的空间

for (i in 0..99) {
    map.put(i.toString(), i) // 不会触发重新分配内存
}

结论

仓颉开发语言中的 Array、ArrayList、HashSet 和 HashMap 是非常强大的数据结构。理解它们的特性和使用场景，并结合具体需求选择合适的类型，能够显著提升代码的性能和可维护性。希望这篇博文能帮助你更好地掌握这些基础 Collection 类型，并在实际开发中充分利用它们的优势。