Swift 语言提供 Arrays 、 Sets 和 Dictionaries 三种基本的集合类型用来存储集合数据。数组(Arrays)是有序
数据的 。 集合(Sets)是无序无重复数据的 。字典(Dictionaries)是无序的键值对的 。

数组(Arrays)

1、创建一个空数组
<pre>
var someInts = Int
print("someInts is of type [Int] with (someInts.count) items.")
// 打印 "someInts is of type [Int] with 0 items."
someInts.append(3)
// someInts 现在包含一个 Int 值
someInts = []
// someInts 现在是空数组，但是仍然是 [Int] 类型的。</pre>

2、创建一个带有默认值的数组
<pre>var threeDoubles = Array(repeating: 0.0, count: 3)
print("someInts is of type [Int] with (threeDoubles.count) items.")
// threeDoubles 是一种 [Double] 数组，等价于 [0.0, 0.0, 0.0]</pre>

3、通过两个数组相加(+)创建一个数组
<pre>var anotherThreeDoubles = Array(repeating: 2.5, count: 3)
// anotherThreeDoubles 被推断为 [Double]，等价于 [2.5, 2.5, 2.5]
var sixDoubles = threeDoubles + anotherThreeDoubles
print(sixDoubles)
// sixDoubles 被推断为 [Double]，等价于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]</pre>

4、用数组字面量构造数组
我们可以使用数组字面量来进行数组构造，这是一种用一个或者多个数值构造数组的简单方法。数组字面量是一系列由逗号分割并由方括号包含的数值:

<pre>var shoppingList: [String] = ["Eggs", "Milk"]
// shoppingList 已经被构造并且拥有两个初始项。</pre>

shoppingList 变量被声明为“字符串值类型的数组“，记作 [String] 。 因为这个数组被规定只有 String 一种 数据结构，所以只有 String 类型可以在其中被存取。 在这里， shoppingList 数组由两个 String 值( "Eggs" 和 "Milk" )构造，并且由数组字面量定义。

由于 Swift 的类型推断机制，当我们用字面量构造只拥有相同类型值数组的时候，我们不必把数组的类型定义清楚。 shoppingList 的构造也可以这样写:
var shoppingList = ["Eggs", "Milk"]

5、访问和修改数组
我们可以通过数组的方法和属性来访问和修改数组，或者使用下标语法。

• 可以使用数组的只读属性 count 来获取数组中的数据项数量:
  print("The shopping list contains (shoppingList.count) items.")
  // 输出 "The shopping list contains 2 items."(这个数组有2个项)

• 使用布尔属性 isEmpty 作为一个缩写形式去检查 count 属性是否为 0 :
  if shoppingList.isEmpty {
  print("The shopping list is empty.")
  } else {
  print("The shopping list is not empty.")
  }
  // 打印 "The shopping list is not empty."(shoppinglist 不是空的)

• 也可以使用 append(_:) 方法在数组后面添加新的数据项:

  shoppingList.append("Flour")
  

• 使用加法赋值运算符( += )也可以直接在数组后面添加一个或多个拥有相同类型的数据项

  shoppingList += ["Baking Powder"]
  // shoppingList 现在有四项了
  shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
  // shoppingList 现在有七项了
  

• 我们也可以用下标来改变某个已有索引值对应的数据值:

    shoppingList[0] = "Six eggs"
    // 其中的第一项现在是 "Six eggs" 而不是 "Eggs"
  

  还可以利用下标来一次改变一系列数据值，即使新数据和原有数据的数量是不一样的，下面的例子把 "Chocolate Spread" ， "Cheese" ，和 "Butter" 替换为 "Bananas" 和 "Apples" :
  shoppingList[4...6] = ["Bananas", "Apples"]
  // shoppingList 现在有6项

注意: 不可以用下标访问的形式去在数组尾部添加新项。

• 调用数组的 insert(_:at:) 方法来在某个具体索引值之前添加数据项:

  shoppingList.insert("Maple Syrup", at: 0)
  // shoppingList 现在有7项
  // "Maple Syrup" 现在是这个列表中的第一项
  

类似的我们可以使用 remove(at:)方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移 除并且返回这个被移除的数据项(我们不需要的时候就可以无视它):
let mapleSyrup = shoppingList.remove(at: 0)
// 索引值为0的数据项被移除
// shoppingList 现在只有6项，而且不包括 Maple Syrup
// mapleSyrup 常量的值等于被移除数据项的值 "Maple Syrup"

    //移除最后一项 removeLast()
    let apples = shoppingList.removeLast()
    // 数组的最后一项被移除了
    // shoppingList 现在只有5项，不包括 Apples 
    // apples 常量的值现在等于 "Apples" 字符串

• 数组的遍历
  1、我们可以使用 for-in 循环来遍历所有数组中的数据项:

    for item in shoppingList {
        print(item)
    }
    // Six eggs
    // Milk
    // Flour
    // Baking Powder
    // Bananas
  

2、 如果我们同时需要每个数据项的值和索引值，可以使用 enumerated() 方法来进行数组遍历。
enumerated() 返回一个由每一个数据项索引值和数据值组成的元组。我们可以把这个元组分解成临时常量或者变量来进行遍历:

    for (index, value) in shoppingList.enumerated() {
        print("Item \(String(index + 1)): \(value)")
    }
    //Item 1: Six eggs
    //Item 2: Milk
    //Item 3: Flour
    //Item 4: Baking Powder
    //Item 5: Bananas

集合(Sets)

集合(Set)用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次时可以使用合而不是数组。

• 1、 创建和构造一个空的集合

    var letters = Set<Character>()
    print("letters is of type Set<Character> with \(letters.count) items.")
    // 打印 "letters is of type Set<Character> with 0 items."
    
    letters.insert("a")
    // letters 现在含有1个 Character 类型的值
    letters = []
    // letters 现在是一个空的 Set, 但是它依然是 Set<Character> 类型
  

• 用数组字面量创建集合

   var favoriteGenres:Set<String> = ["Rock","Classical","hip hop"]
   
   //简写，类型推断
   var favoriteGenres1: Set = ["Rock", "Classical", "Hip hop"]
  

• 2、访问和修改一个集合

  • 为了找出一个 Set 中元素的数量，可以使用其只读属性 count :
    <pre> print("I have (favoriteGenres.count) favorite music genres.")
    // 打印 "I have 3 favorite music genres."</pre>

  • 使用布尔属性 isEmpty 作为一个缩写形式去检查 count 属性是否为 0 :
    <pre> if favoriteGenres.isEmpty {
    print("As far as music goes, I'm not picky.")
    } else {
    print("I have particular music preferences.")
    }
    // 打印 "I have particular music preferences.</pre>

  • 你可以通过调用 Set 的 insert(_:) 方法来添加一个新元素:
    <pre>favoriteGenres.insert("Jazz")
    // favoriteGenres 现在包含4个元素</pre>

  • 你可以通过调用 Set 的 remove(_:) 方法去删除一个元素，如果该值是该 Set 的一个元素则删除该元素并且返回被删除的元素值，否则如果该 Set 不包含该值，则返回 nil 。另外， Set 中的所有元素可以通过它的 removeAl l() 方法删除

    <pre> if let removedGenre = favoriteGenres.remove("Rock") {
    print("(removedGenre)? I'm over it.")
    } else {
    print("I never much cared for that.")
    }
    // 打印 "Rock? I'm over it."</pre>

  • 使用 contains(_:) 方法去检查 Set 中是否包含一个特定的值:

    <pre> if favoriteGenres.contains("Funk") {
    print("I get up on the good foot.")
    } else {
    print("It's too funky in here.")
    }
    // 打印 "It's too funky in here."</pre>

• 遍历一个集合

   for genre in favoriteGenres {
       print("\(genre)")
   }
   // Classical
   // Jazz
   // Hip hop
  

Swift 的 Set 类型没有确定的顺序，为了按照特定顺序来遍历一个 Set 中的值可以使用 sorted() 方法，它将返回一个有序数组，这个数组的元素排列顺序由操作符'<'对元素进行比较的结果来确定.
for genre in favoriteGenres.sorted() {
print("(genre)")
}
// prints "Classical"
// prints "Hip hop"
// prints "Jazz

• 3、集合操作
  你可以高效地完成 Set 的一些基本操作，比如把两个集合组合到一起，判断两个集合共有元素，或者判断两个集合是否全包含，部分包含或者不相交。

  • 基本集合操作

  • 使用 intersection(:) 方法根据两个集合中都包含的值创建的一个新的集合。
  • 使用 symmetricDifference(:) 方法根据在一个集合中但不在两个集合中的值创建一个新的集合。
  • 使用 union(:) 方法根据两个集合的值创建一个新的集合。
  • 使用 subtracting(:) 方法根据不在该集合中的值创建一个新的集合。

    let oddDigits: Set = [1, 3, 5, 7, 9]
    let evenDigits: Set = [0, 2, 4, 6, 8]
    let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]
    oddDigits.union(evenDigits).sorted()
    // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    oddDigits.intersection(evenDigits).sorted()
    // []
    oddDigits.subtracting(singleDigitPrimeNumbers).sorted()
    // [1, 9]
    oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted()
    // [1, 2, 9]
  

  • 合成员关系和相等
    • 使用“是否相等”运算符( == )来判断两个集合是否包含全部相同的值。
    • 使用 isSubset(of:) 方法来判断一个集合中的值是否也被包含在另外一个集合中。
    • 使用 isSuperset(of:) 方法来判断一个集合中包含另一个集合中所有的值。
    • 使用 isStrictSubset(of:) 或者 isStrictSuperset(of:) 方法来判断一个集合是否是另外一个集合的子集合或者父 集合并且两个集合并不相等。
    • 使用 isDisjoint(with:) 方法来判断两个集合是否不含有相同的值(是否没有交)。

    let houseAnimals: Set = ["?", "?"]
    let farmAnimals: Set = ["?", "?", "?", "?", "?"]
    let cityAnimals: Set = ["?", "?"]
    houseAnimals.isSubset(of: farmAnimals)
    // true
    farmAnimals.isSuperset(of: houseAnimals)
    // true
    farmAnimals.isDisjoint(with: cityAnimals)
    // true
    

字典(Dictionary)

字典是一种存储多个相同类型的值的容器。每个值(value)都关联唯一的键(key)，键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序.
Swift 的字典使用 Dictionary<Key, Value> 定义，其中 Key 是字典中键的数据类型， Value 是字典中对应于这些 键所存储值的数据类型。

1、 创建一个空字典
<pre>var namesOfIntegers = Int : String
// namesOfIntegers 是一个空的 [Int: String] 字典
namesOfIntegers[16] = "sixteen"
// namesOfIntegers 现在包含一个键值对
namesOfIntegers = [:]
// namesOfIntegers 又成为了一个 [Int: String] 类型的空字典
//用字典字面量构造字典
var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
print(airports)</pre>

** 2、访问和修改字典**

• 通过字典的只读属性 count 来获取某个字典的数据项数量:
  <pre>print("The dictionary of airports contains (airports.count) items.")
  // 打印 "The dictionary of airports contains 2 items."(这个字典有两个数据项)</pre>

• 使用布尔属性 isEmpty 作为一个缩写形式去检查 count 属性是否为 0 :
  if airports.isEmpty {
  print("The airports dictionary is empty.")
  } else {
  print("The airports dictionary is not empty.")
  }
  // 打印 "The airports dictionary is not empty."

• 添加：字典中使用下标语法来添加新的数据项
  airports["LHR"] = "London"
  // airports 字典现在有三个数据项

    airports["LHR"] = "London Heathrow"
    // "LHR"对应的值 被改为 "London Heathrow
  

• 修改： 作为另一种下标方法，字典的 updateValue(:forKey:) 方法可以设置或者更新特定键对应的值,
  和上面的下标方法不同的， updateValue(:forKey:) 这个方法返回更新值之前的原值。这样使得我们可以检查更新是否成功。
  updateValue(_:forKey:) 方法会返回对应值的类型的可选值。举例来说:对于存储 String 值的字典，这个函数会返回一个 String? 或者“可选 String ”类型的值。
  如果有值存在于更新前，则这个可选值包含了旧值，否则它将会是 nil 。

   if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {
       print("The old value for DUB was \(oldValue).")
   }
   // 输出 "The old value for DUB was Dublin."
   print(airports)
  

• 如果这个字典包含请求键所对应的值，下标会返回一个包含这个存在值的可选值，否则将返回 nil :
  if let airportName = airports["DUB"] {
  print("The name of the airport is (airportName).")
  } else {
  print("That airport is not in the airports dictionary.")
  }
  // 打印 "The name of the airport is Dublin Airport."

• 删除：
  *通过给某个键的对应值赋值为 nil 来从字典里移除一个键值对:

   airports["APL"] = "Apple Internation"
   print(airports)
   // "Apple Internation" 不是真的 APL 机场, 删除它
   airports["APL"] = nil
   print(airports)
   // APL 现在被移除了
  

*removeValue(forKey:) 方法也可以用来在字典中移除键值对。这个方法在键值对存在的情况下会移除该键值对并且返回被移除的值或者在没有值的情况下返回 nil :
if let removedValue = airports.removeValue(forKey: "DUB") {
print("The removed airport's name is (removedValue).")
} else {
print("The airports dictionary does not contain a value for DUB.")
}
// prints "The removed airport's name is Dublin Airport."

• 3、字典遍历

  • 我们可以使用 for-in 循环来遍历某个字典中的键值对。每一个字典中的数据项都以 (key, value) 元组形式返 回，并且我们可以使用临时常量或者变量来分解这些元组:

    <pre>for (airportCode, airportName) in airports {
    print("(airportCode): (airportName)")
    }
    // YYZ: Toronto Pearson
    // LHR: London Heathrow</pre>

  • 通过访问keys或者values属性，我们也可以遍历字典的键或者值:

    <pre> for airportCode in airports.keys {
    print("Airport code: (airportCode)")
    }
    // Airport code: YYZ
    // Airport code: LHR
    for airportName in airports.values {
    print("Airport name: (airportName)")
    }
    // Airport name: Toronto Pearson
    // Airport name: London Heathrow</pre>

可以直接使用keys或者values属性构造一个新数组
<pre> let airportCodes = Array(airports.keys)
print(airportCodes)
// airportCodes 是 ["YYZ", "LHR"]
let airportNames = Array(airports.values)
print(airportNames)
// airportNames 是 ["Toronto Pearson", "London Heathrow"] </pre>