Swift有三种主要的集合类型,分别是:

  • Arrays
  • Sets
  • dictionaries

数组(Arrays)

数组是包含相同数据类型有序数据集合,允许相同的数据出现在不同的位置。

创建一个空数组

1
2
3
4
5
6
// 两种不同的写法
var someInts = [Int]()
var anotherInts: [Int] = []

print(someInts.count) // 0
print(anotherInts.count) // 0

创建有值的数组

1
var shoppingList: [String] = ["Eggs", "Milk"]

创建含有默认值的数组

1
2
var threeDoubles = Array(repeating: 0.0, count: 3)
print(threeDoubles) // [0.0, 0.0, 0.0]

通过相加数组创建新的数组

1
2
3
4
5
6
7
var threeDoubles = Array(repeating: 0.0, count: 3)
print(threeDoubles)

var anotherTrheeDoubles = Array(repeating: 2.5, count: 3)

var sixDoubles = threeDoubles + anotherTrheeDoubles
print(sixDoubles) // [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

数组常用的属性和方法

  • 跟字符串类型类似,使用count属性获取数组元素的个数, 使用isEmpty属性可以检查数组是否为空。

  • 使用append方法可以添加一个元素到数组

  • 使用+=可以添加一个数组到另一个数组

    1
    2
    3
    4
    5
    
    var shoppingList: [String] = ["Eggs", "Milk"]
    
    shoppingList.append("Flour")
    
    shoppingList += ["Baking", "Powder"]
  • 使用下标可以修改数组元素

    1
    2
    3
    4
    
    shoppingList[0] = "Six Eggs"
    
    // 下标指定的元素个数和赋值的元素个数不一定要相同
    shoppingList[1...4] = ["Bananas", "Apples"]
  • 插入/删除一个元素

    1
    2
    3
    4
    5
    6
    7
    
    shoppingList.insert("Maple Syrup", at: 0)
    
    // 删除指定位置的元素
    shoppingList.remove(at: 3)
    
    // 删除最后一个元素
    shoppingList.removeLast()
  • 遍历数组

    1
    2
    3
    
    for item in shoppingList {
        print(item)
    }

集合(Sets)

集合就是无序唯一相同数据类型的集合

集合的中的数据类型必须是hashble

为了实现唯一性,集合中的元素必须是hashble的,比较两个元素是否相同时,比较的其实就是hash值,比如a == b 就是比较a.hashValue == b.hashValue

所有的Swift基础类型(String, Int, DoubleBool)默认都是hashble的。当自定义类型需要加入到Sets时,需要自己实现Hashable协议。

创建集合

1
2
3
4
5
6
7
8
// 创建一个空集合
var letters = Set<Character>()
var anohterletters: Set<Character> = []

// 创建初始有值的集合
var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
// 简写形式
var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]

集合常用的属性和方法

  • 跟字符串类型类似,使用count属性获取集合元素的个数, 使用isEmpty属性可以检查集合是否为空。

  • 往集合添加元素可以使用insert(_:)方法, 删除元素使用remove(_:) 方法, 检查是否包含某个元素可以使用contains(_:)方法

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    
    var fruits: Set = ["Apple", "Pear", "Orange"]
    fruits.insert("Banana")
    fruits.remove("Apple")
    
    fruits.contains("Pear")
    
    // 遍及集合
    for fruit in fruits {
        print(fruit)
    }

集合操作

Set Opearations

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
let oddDigits: Set = [1,3,5,7,9]
let evenDigits: Set = [0,2,4,6,8]
let singleDigitPrimerNumbers:Set = [2,3,5,7]

// 两个集合的交集
print(oddDigits.intersection(evenDigits).sorted()) // []
// 两个集合交集以外的集合
print(oddDigits.symmetricDifference(singleDigitPrimerNumbers).sorted()) // [1, 2, 9]
// 两个集合的并集
print(oddDigits.union(evenDigits).sorted()) // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
// 属于集合a, 但是不属于集合b
print(oddDigits.subtracting(singleDigitPrimerNumbers).sorted()) // [1, 9]

集合关系

假如有三个集合a, b, c的关系如下图所示:

  • ab的父集,a包含所有b中的元素
  • ba的自己,b中的元素a中都有
  • bc没有相交,它们之间没有相同的元素

set membership

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
let houseAnimals: Set = ["🐶", "🐱"]
let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
let cityAnimals: Set = ["🐦", "🐭"]

// 用"=="判断两个集合是否相同
houseAnimals == cityAnimals // false
// 是否是子集(两个集合可能相等)
houseAnimals.isSubset(of: farmAnimals) // true
// 是否是父集
farmAnimals.isSuperset(of: houseAnimals) // true
// 是否不相交
farmAnimals.isDisjoint(with: cityAnimals) // true

// 判断是否是子集或父集(两个集合不相等)
houseAnimals.isStrictSubset(of: farmAnimals) // true
farmAnimals.isStrictSuperset(of: houseAnimals) // true

houseAnimals.isSubset(of: houseAnimals)  // true
houseAnimals.isStrictSubset(of: houseAnimals) // false

字典(Dictionaries)

字典就是键值对的集合,跟Set类型一样,字典的键也必须是hashble的,字段中的元素都是无序的

创建一个空字典

1
var namesOfIntegers = [Int: String]()

使用字典语法创建字典

1
var airports:[String: String] = ["XYZ": "Toronto Pearson", "DUB": "Dublin"]

数组常用的属性和方法

  • 跟数组一样,可以使用*只读*属性count获取字典中的元素个数
  • 使用isEmpty属性检查字典元素格式是否为0
  • 可以直接使用下标访问字典

    1
    2
    
    airports["LHR"] = "London"
    airports["LHR"] = "London Heathrow"
  • 除了上面通过下标的方式修改元素的值之外,也可以使用updateValue(_:forKey:)来修改元素的值,与使用下标方式不同的值,如果指定的key存在的话,它除了改变key的值之外,还会返回key之前的值

    1
    2
    3
    4
    
    airports["Name"] = "John"
    if let oldValue = airports.updateValue("Crazygit", forKey: "Name") {
        print(oldValue) // print "John"
    }
  • 通过下标访问字段的时候,返回的值也是可选值类型, 当key不存在时,直接返回nil

    1
    2
    3
    4
    5
    6
    
    if let name = airports["Name"] {
        print(name)
    }
    else {
        print("No Name")
    }
  • 删除元素有两种方式,一种是使用下标的方式,将元素赋值为nil

    1
    2
    
    airports["Name"] = nil
    print(airports)  // Name键已经从字典中移除

    另一种方式是使用removeValue(forkey:)方法,与通过下标访问的不同的是,它会返回被移除的值

    1
    2
    3
    4
    5
    6
    
    if let removedValue = airports.removeValue(forKey: "DUB") {
        print("Remove key DUB from airports dict")
    }
    else{
        print("airport dict dose not contain a value for DUB")
    }
  • 遍历字典

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    
    // 遍历键和值
    for (key, value) in airports {
        print("\(key) => \(value)")
    }
    
    // 遍历键
    for key in airports.keys {
        print(key)
    }
    
    // 遍历值
    for value in airports.values {
        print(value)
    }