访问HashSet成员#

当需要对HashSet的所有元素进行访问时, 可以使用for-in循环遍历HashSet的所有元素

需要注意的是, HashSet并不保证按插入元素的顺序排列, 因此遍历的顺序和插入的顺序可能不同

1
import std.collection.*
2

3
main() {
4
    let mySet = HashSet<Int64>([0, 1, 2])
5
    for (i in mySet) {
6
        println("The element is ${i}")
7
    }
8
}

编译并执行上面的代码, 有可能会输出:

1
The element is 0
2
The element is 1
3
The element is 2

当需要知道某个HashSet包含的元素个数时, 可以使用size属性获得对应信息

1
import std.collection.*
2

3
main() {
4
    let mySet = HashSet<Int64>([0, 1, 2])
5
    if (mySet.size == 0) {
6
        println("This is an empty hashset")
7
    } else {
8
        println("The size of hashset is ${mySet.size}")
9
    }
10
}

编译并执行上面的代码, 会输出:

1
The size of hashset is 3

当想判断某个元素是否被包含在某个HashSet中时, 可以使用contains函数

如果该元素存在会返回true, 否则返回false

1
let mySet = HashSet<Int64>([0, 1, 2])
2
let a = mySet.contains(0)                 // a == true
3
let b = mySet.contains(-1)                // b == false

HashSet不能使用下标随机访问元素

只能在遍历所有元素时 访问元素, 比如使用for-in循环遍历HashSet的元素

但, HashSet可以通过contains()函数, 判断目标元素是否存在, 存在返回true, 不存在返回false

修改HashSet#

HashSet是一种可变的引用类型, HashSet类型提供了添加元素、删除元素的功能

HashSet的可变性是一个非常有用的特征, 可以让同一个HashSet实例的所有引用都共享同样的元素, 并且对它们统一进行修改

如果需要将单个元素添加到HashSet里, 请使用add函数

如果希望同时添加多个元素, 可以使用add(all!: Collection<T>)函数, 这个函数可以接受另一个相同元素类型的Collection类型(例如Array)

当元素不存在时, add函数会执行添加的操作, 当HashSet中存在相同元素时, add函数将不会有效果

1
let mySet = HashSet<Int64>()
2
mySet.add(0)                  // mySet 包含元素 0
3
mySet.add(0)                  // mySet 包含元素 0
4
mySet.add(1)                  // mySet 包含元素 0, 1
5
let li = [2, 3]
6
mySet.add(all: li)            // mySet 包含元素 0, 1, 2, 3

HashSet是引用类型, HashSet在作为表达式使用时不会拷贝副本, 同一个HashSet实例的所有引用都会共享同样的数据

因此对HashSet元素的修改会影响到该实例的所有引用

1
let set1 = HashSet<Int64>([0, 1, 2])
2
let set2 = set1
3
set2.add(3)
4
// set1 包含元素 0, 1, 2, 3
5
// set2 包含元素 0, 1, 2, 3

从HashSet中删除元素, 可以使用remove函数, 需要指定删除的元素

1
let mySet = HashSet<Int64>([0, 1, 2, 3])
2
mySet.remove(1)                           // mySet 包含元素 0, 2, 3

HashSet中已存在的元素, 是无法原地修改的, 但可以先删除旧元素 再添加新元素

HashSet提供有 添加元素(add()函数)和删除元素(remove()函数) 的功能

HashSet内不允许存在重复的元素, 所以当使用add()函数 不会向HashSet添加已存在的元素

HashSet的add()也可以传入其他同元素类型的Collection实例

HashSet的remove()函数, 可以删除目标元素

访问HashMap成员#

当需要对HashMap的所有元素进行访问时, 可以使用for-in循环遍历HashMap的所有元素

需要注意的是, HashMap并不保证按插入元素的顺序排列, 因此遍历的顺序和插入的顺序可能不同

1
import std.collection.*
2

3
main() {
4
    let map = HashMap<String, Int64>([("a", 0), ("b", 1), ("c", 2)])
5
    for ((k, v) in map) {
6
        println("The key is ${k}, the value is ${v}")
7
    }
8
}

编译并执行上面的代码, 有可能会输出:

1
The key is a, the value is 0
2
The key is b, the value is 1
3
The key is c, the value is 2

当需要知道某个HashMap包含的元素个数时, 可以使用size属性获得对应信息

1
import std.collection.*
2

3
main() {
4
    let map = HashMap<String, Int64>([("a", 0), ("b", 1), ("c", 2)])
5
    if (map.size == 0) {
6
        println("This is an empty hashmap")
7
    } else {
8
        println("The size of hashmap is ${map.size}")
9
    }
10
}

编译并执行上面的代码, 会输出:

1
The size of hashmap is 3

当想判断HashMap中是否包含某个键时, 可以使用contains函数

如果该键存在会返回true, 否则返回false

1
let map = HashMap<String, Int64>([("a", 0), ("b", 1), ("c", 2)])
2
let a = map.contains("a")                                         // a == true
3
let b = map.contains("d")                                         // b == false

当想访问指定键对应的元素时, 可以使用下标语法访问(下标的类型必须是键类型)

使用不存在的键作为索引会触发运行时异常

1
let map = HashMap<String, Int64>([("a", 0), ("b", 1), ("c", 2)])
2
let a = map["a"]                                                  // a == 0
3
let b = map["b"]                                                  // b == 1
4
let c = map["d"]                                                  // 运行时异常

HashMap可以通过下标语法, 使用确认存在的键, 访问目标键的值

也可以遍历访问元素

同样提供有contains()函数, 用来判断目标键是否存在

修改HashMap#

HashMap是一种可变的引用类型, HashMap类型提供了修改元素、添加元素、删除元素的功能

HashMap的可变性是一个非常有用的特征, 可以让同一个HashMap实例的所有引用都共享同样的元素, 并且对它们统一进行修改

可以使用下标语法对某个键对应的值进行修改

1
let map = HashMap<String, Int64>([("a", 0), ("b", 1), ("c", 2)])
2
map["a"] = 3

HashMap是引用类型, HashMap在作为表达式使用时不会拷贝副本, 同一个HashMap实例的所有引用都会共享同样的数据

因此对HashMap元素的修改会影响到该实例的所有引用

1
let map1 = HashMap<String, Int64>([("a", 0), ("b", 1), ("c", 2)])
2
let map2 = map1
3
map2["a"] = 3
4
// map1 包含元素 ("a", 3), ("b", 1), ("c", 2)
5
// map2 包含元素 ("a", 3), ("b", 1), ("c", 2)

如果需要将单个键值对添加到HashMap里, 请使用add函数

如果希望同时添加多个键值对, 可以使用add(all!: Collection<(K, V)>)函数

当键不存在时, add函数会执行添加的操作, 当键存在时, add函数会将新的值覆盖旧的值

1
let map = HashMap<String, Int64>()
2
map.add("a", 0)                                           // map 包含元素 ("a", 0)
3
map.add("b", 1)                                           // map 包含元素 ("a", 0), ("b", 1)
4
let map2 = HashMap<String, Int64>([("c", 2), ("d", 3)])
5
map.add(all: map2)                                        // map 包含元素 ("a", 0), ("b", 1), ("c", 2), ("d", 3)

除了使用add函数以外, 也可以使用赋值的方式直接将新的键值对添加到HashMap

1
let map = HashMap<String, Int64>([("a", 0), ("b", 1), ("c", 2)])
2
map["d"] = 3                                              // map 包含元素 ("a", 0), ("b", 1), ("c", 2), ("d", 3)

从HashMap中删除元素, 可以使用remove函数, 需要指定删除的键

1
let map = HashMap<String, Int64>([("a", 0), ("b", 1), ("c", 2), ("d", 3)])
2
map.remove("d")                                           // map 包含元素 ("a", 0), ("b", 1), ("c", 2)

HashMap可以通过下标语法访问 指定键的值, 当然也可以通过下标语法 修改指定键的值

1
hashMap["key"] = value

使用下标语法修改指定键的值时, 与只是访问指定键的值不同:

使用下标语法访问指定键的值, 如果指定键不存在, 则会 触发运行时异常

但, 使用下标语法修改指定键的值时, 如果指定键不存在, 则会 新增目标键值对

除此之外HashMap可以使用add()函数, 添加一个键值对, 如果目标键已存在, 则会修改键对应的值

add()函数, 也可以 传入同元素类型的HashMap添加一系列的键值对

add()函数, 更可以 传入其他的Collection类型, 但 要保证元素类型为Tuple<K, V>

HashMap可以使用remove()函数, 传入单个键, 尝试删除单个目标键值对

也可以传入其他 同键类型的Collection类型数据, 尝试删除一系列键值对

TIP

仓颉HashMap, 使用remove()尝试删除键值对时, 如果键不存在, 不会触发异常

而 使用下标语法访问目标键的值时, 如果目标键不存在, 会触发异常

HashSet和HashMap都是通过元素(或Key)的哈希值 来确定元素的存储位置的

所以, 元素(或Key)类型要满足 实现Hashable和Equatable<K>接口的要求

本篇文章只是介绍HashSet和HashMap最基本的使用, 更详细的使用可以阅读标准库API的使用或相关源码