IOS Swift学习之集合类型

##数组（Array）

Swift 中的数组是类型安全的，并且它们中包含的类型必须明确。

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

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

使用数组的只读属性`count`来获取数组中的数据项数量。

```swift
println("The shopping list contains \(shoppingList.count) items.")
// 输出"The shopping list contains 2 items."（这个数组有2个项）
```

也可以使用`append`方法在数组后面添加新的数据项：

```swift
shoppingList.append("Flour")
// shoppingList 现在有3个数据项，有人在摊煎饼
```

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

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

可以利用下标来一次改变一系列数据值，即使新数据和原有数据的数量是不一样的。

```swift
shoppingList[4...6] = ["Bananas", "Apples"]
// shoppingList 现在有六项，去掉了一项

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

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

可以使用`removeAtIndex`方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项

```swift
let mapleSyrup = shoppingList.removeAtIndex(0)
// 索引值为0的数据项被移除
// shoppingList 现在只有6项，而且不包括Maple Syrup
// mapleSyrup常量的值等于被移除数据项的值 "Maple Syrup"
```

可以使用`removeLast`方法移除数组最后一项，并返回被移除的数据项

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

使用`for-in`循环来遍历所有数组中的数据项：


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

当我们同时需要每个数据项的值和索引值，可以使用全局`enumerate`函数来进行数组遍历。`enumerate`返回一个由每一个数据项索引值和数据值组成的元组。我们可以把这个元组分解成临时常量或者变量来进行遍历：

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

可以使用构造语法来创建一个由特定数据类型构成的空数组：

```swift
var someInts = [Int]()
println("someInts is of type [Int] with \(someInts.count) items。")
// 打印 "someInts is of type [Int] with 0 items。"（someInts是0数据项的Int[]数组）
```

`Array`类型还提供一个可以创建特定大小并且所有数据都被默认的构造方法。我们可以把准备加入新数组的数据项数量（`count`）和适当类型的初始值（`repeatedValue`）传入数组构造函数：

```swift
var threeDoubles = [Double](count: 3, repeatedValue:0.0)
// threeDoubles 是一种 [Double]数组, 等于 [0.0, 0.0, 0.0]
```

可以使用加法操作符（`+`）来组合两种已存在的相同类型数组。新数组的数据类型会被从两个数组的数据类型中推断出来：

```swift
var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles 被推断为 [Double], 等于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]
```

##集合（Set）

通过构造器语法创建一个特定类型的空集合：

```swift
var letters = Set<Character>()
println("letters is of type Set<Character> with \(letters.count) items.")
// 打印 "letters is of type Set<Character> with 0 items."
```

使用一个数组字面量来构造一个集合

```swift
var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
// favoriteGenres被构造成含有三个初始值的集合
```

一个```Set```类型不能从数组中字面量中独立地被推断出来，因此```Set```类型必须显式声明。然而，由于Swift的类型推导功能，如果你想使用一个数组字面量构造一个Set并且该数组字面量中的所有元素类型相同，那么你无须写出```Set```的具体类型。```favoriteGenres```的构造形式可以采用简化的方式代替：

```swift
var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]
```

可以使用其只读属性```count```，使用布尔属性```isEmpty```作为一个缩写形式去检查```count```属性是否为```0```，通过调用```Set```的``` insert(_:) ```方法添加一个新的元素

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

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

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

可以在一个```for-in```循环中遍历一个```Set```中的所有值。

for genre in favoriteGenres {
    println("\(genre)")
}

可以使用全局```sorted```函数，它将根据提供的序列返回一个排序的集合.

for genre in sorted(favoriteGenres) {
    println("\(genre)")
}

两个集合可以方便的构造一个新的集合

* 使用```union(_:)```方法根据两个集合的值创建一个新的集合。
* 使用```subtract(_:)```方法根据不在该集合中的值创建一个新的集合。
* 使用```intersect(_:)```方法根据两个集合中都包含的值创建的一个新的集合。
* 使用```exclusiveOr(_:)```方法根据值在一个集合中但不在两个集合中的值创建一个新的集合。

```swift
let oddDigits: Set = [1, 3, 5, 7, 9]
let evenDigits: Set = [0, 2, 4, 6, 8]
let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]
sorted(oddDigits.union(evenDigits))
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
sorted(oddDigits.intersect(evenDigits))
// []
sorted(oddDigits.subtract(singleDigitPrimeNumbers))
// [1, 9]
sorted(oddDigits.exclusiveOr(singleDigitPrimeNumbers))
// [1, 2, 9]
```

* 使用“是否等”运算符(```==```)来判断两个集合是否包含相同的值。
* 使用```isSubsetOf(_:)```方法来判断一个集合中的值是否也被包含在另外一个集合中。
* 使用```isSupersetOf(_:)```方法来判断一个集合中包含的值是另一个集合中所有的值。
* 使用```isStrictSubsetOf(_:)```或者```isStrictSupersetOf(_:)```方法来判断一个集合是否是另外一个集合的子集合或者父集合并且和特定集合不相等。
* 使用```isDisjointWith(_:)```方法来判断两个结合是否不含有相同的值。

```swift
let houseAnimals: Set = ["