集合：唯一元素的集合

有时，您需要一种集合，它只跟踪一组项目，其中每个项目都是唯一的且顺序无关紧要。尽管像数组这样的数据结构管理有序序列，而字典处理键值映射，但它们不提供这种特定功能。这就是集合发挥作用的地方。Julia 中的集合，就像其在数学上的对应物一样，是无序的互不相同元素的汇集。

集合在以下情况中特别有用：

• 快速判断一个项目是否属于某个集合。
• 确保集合只包含唯一项目（例如，从列表中移除重复项）。
• 执行标准的集合操作，如集合并集、交集和差集。

创建集合

您可以使用 Set 构造函数在 Julia 中创建集合。如果要创建空集合，通常需要指定它将容纳的元素类型。如果使用初始元素创建集合，Julia 通常可以推断出其类型。

创建一个用于存放整数的空集合：

julia> empty_int_set = Set{Int}()
Set{Int64}()

julia> typeof(empty_int_set)
Set{Int64}

这里，Set{Int}() 创建了一个专门用于存储整数的空集合（Int64 是大多数系统上的默认整数类型）。

要创建一个包含初始元素的集合，您可以将一个可迭代的集合（例如数组）传递给 Set 构造函数：

julia> fruit_set = Set(["apple", "banana", "orange"])
Set{String} with 3 elements:
  "orange"
  "banana"
  "apple"

julia> number_set = Set([1, 2, 2, 3, 1, 4])
Set{Int64} with 4 elements:
  4
  2
  3
  1

在 number_set 示例中请注意两点：

1. 唯一性：尽管输入数组 [1, 2, 2, 3, 1, 4] 包含重复值（1 和 2 出现了两次），但生成的集合 Set{Int64}{4, 2, 3, 1} 只包含每个互不相同的元素一次。
2. 无序性：集合的打印表示 (4, 2, 3, 1) 中的元素不一定与它们提供时的顺序相同，也不是按数字顺序排列。集合不保证其元素的任何特定顺序。

基本集合操作

一旦有了集合，就可以执行一些基本操作。

添加元素

要向集合中添加元素，请使用 push! 函数。如果元素已存在于集合中，集合将保持不变，因为元素必须是唯一的。

julia> colors = Set(["red", "green"])
Set{String} with 2 elements:
  "green"
  "red"

julia> push!(colors, "blue")
Set{String} with 3 elements:
  "green"
  "blue"
  "red"

julia> push!(colors, "red") # 再次添加 "red"
Set{String} with 3 elements:
  "green"
  "blue"
  "red"
# 集合仍然包含 3 个元素，"red" 没有再次被添加。

检查成员关系

集合的一个常见用途是检查元素是否存在。这可以通过使用 in 关键字或其函数形式 in(element, set) 来完成。对于集合，成员关系测试通常非常高效。

julia> names = Set(["Alice", "Bob", "Charlie"])
Set{String} with 3 elements:
  "Alice"
  "Charlie"
  "Bob"

julia> "Bob" in names
true

julia> in("David", names)
false

移除元素

要从集合中移除元素，可以使用 pop! 或 delete!。pop!(set, element) 移除指定元素并返回它。如果未找到该元素，则会抛出错误。delete!(set, element) 移除元素并返回修改后的集合；如果未找到该元素，则不会报错。

julia> items = Set([10, 20, 30, 40])
Set{Int64} with 4 elements:
  40
  20
  30
  10

julia> pop!(items, 30) # 移除 30
30

julia> items
Set{Int64} with 3 elements:
  40
  20
  10

julia> delete!(items, 20) # 移除 20
Set{Int64} with 2 elements:
  40
  10

julia> pop!(items, 50) # 元素 50 不在集合中
ERROR: KeyError: key 50 not found
Stacktrace:
 [1] pop!(s::Set{Int64}, key::Int64)
   @ Base ./set.jl:106
 [2] top-level scope
   @ REPL[8]:1

julia> delete!(items, 50) # 元素 50 不在集合中，没有报错
Set{Int64} with 2 elements:
  40
  10

您也可以使用不指定元素的 pop!(set) 来移除并返回集合中的任意元素。当您希望逐个处理元素而不关心具体是哪个元素时，这很有用。

获取大小

要查看集合中有多少元素，请使用 length 函数：

julia> simple_set = Set(['a', 'b', 'c'])
Set{Char} with 3 elements:
  'c'
  'a'
  'b'

julia> length(simple_set)
3

集合论操作

Julia 的集合支持标准的数学集合操作，这对于比较和组合集合非常强大。

并集

两个集合的并集，表示为 $A \cup B$，创建一个新集合，其中包含集合 A 中、集合 B 中或同时在两者中的所有元素。Julia 提供了 union 函数或 ∪ 运算符（您可以在 Julia REPL 或许多编辑器中键入 \cup 然后按 TAB 键）。

julia> set1 = Set([1, 2, 3])
Set{Int64} with 3 elements:
  2
  3
  1

julia> set2 = Set([3, 4, 5])
Set{Int64} with 3 elements:
  4
  3
  5

julia> union(set1, set2)
Set{Int64} with 5 elements:
  4
  2
  3
  5
  1

julia> set1 ∪ set2 # 使用 ∪ 运算符
Set{Int64} with 5 elements:
  4
  2
  3
  5
  1

交集

两个集合的交集，$A \cap B$，创建一个新集合，其中只包含集合 A 和集合 B 都共同拥有的元素。使用 intersect 函数或 ∩ 运算符（键入 \cap 然后按 TAB 键）。

julia> set1 = Set([1, 2, 3, 4])
Set{Int64} with 4 elements:
  4
  2
  3
  1

julia> set2 = Set([3, 4, 5, 6])
Set{Int64} with 4 elements:
  4
  3
  5
  6

julia> intersect(set1, set2)
Set{Int64} with 2 elements:
  4
  3

julia> set1 ∩ set2 # 使用 ∩ 运算符
Set{Int64} with 2 elements:
  4
  3

差集

两个集合的差集，$A \setminus B$（或 $A - B$），创建一个新集合，其中包含存在于集合 A 中但不存在于集合 B 中的元素。Julia 使用 setdiff 函数。

julia> set_a = Set(["apple", "banana", "cherry"])
Set{String} with 3 elements:
  "cherry"
  "banana"
  "apple"

julia> set_b = Set(["banana", "date"])
Set{String} with 2 elements:
  "date"
  "banana"

julia> setdiff(set_a, set_b) # 存在于 set_a 但不存在于 set_b 的元素
Set{String} with 2 elements:
  "cherry"
  "apple"

julia> setdiff(set_b, set_a) # 存在于 set_b 但不存在于 set_a 的元素
Set{String} with 1 element:
  "date"

对称差集

两个集合的对称差集，$A \Delta B$，创建一个新集合，其中包含存在于集合 A 或集合 B 中，但不同时存在于两者的元素。Julia 使用 symdiff 函数。

julia> set_x = Set([10, 20, 30])
Set{Int64} with 3 elements:
  20
  30
  10

julia> set_y = Set([20, 40, 50])
Set{Int64} with 3 elements:
  40
  20
  50

julia> symdiff(set_x, set_y) # 存在于其中一个集合但不同时存在于两者的元素
Set{Int64} with 4 elements:
  40
  10
  30
  50
# 结果是 {10, 30, 40, 50}，因为 20 同时存在于两者。

遍历集合

您可以使用 for 循环遍历集合中的元素，就像处理数组一样。但是，请记住集合是无序的，因此元素将按任意顺序处理，不一定按插入顺序或任何排序顺序。

julia> my_set = Set(["cat", "dog", "bird"])
Set{String} with 3 elements:
  "cat"
  "bird"
  "dog"

julia> for animal in my_set
           println("发现了一个 ", animal)
       end
Found a cat
Found a bird
Found a dog
# 输出顺序可能不同。

何时使用集合

集合是您 Julia 编程工具箱中的一个有价值的工具。在以下情况中考虑使用集合：

• 您需要存储不允许重复的项的集合。例如，跟踪网站的唯一访客。
• 您需要非常快速地检查集合中是否存在某个项目（成员关系测试）。这通常比遍历数组更快，特别是对于大型集合。
• 您需要执行逻辑操作，例如查找两个列表之间的共同项目（交集）或合并两个列表同时只保留唯一项目（并集）。例如，查找两个用户之间的共同好友。
• 您希望轻松地从现有数组中移除重复项：unique_items = Set(my_array)。

了解集合，以及数组、元组和字典，为您在 Julia 程序中组织和管理数据提供了灵活的选择范围。每种集合类型都有其优势，选择正确的类型可以使您的代码更整洁、更高效且更易于理解。