Swift-集合类型

//: Playground - noun: a place where people can play

import UIKit

var str = "Hello, playground"

//空数组
//通过构造函数的类型，someInts的值类型被推断为[Int]
var someInts = [Int]() ;
print("someInts is of type [Int] with \(someInts.count) items。") ;
someInts.append(3);
someInts = [] ;

//创建一个带有默认值的数组
//新数组的数据项数量（count）和适当类型的初始值（repeatedValue）传入数组构造函数
var threeDoubles = [Double](count:3,repeatedValue:0.0);

//通过两个数组相加创建一个数组
var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5) ;
var sixDoubles = threeDoubles + anotherThreeDoubles ;

//用字面量构造数组
var shoppingList: [String] = ["Eggs", "Milk"] ;

//访问和修改数组
print("The shopping list contains \(shoppingList.count) items.") ;

//用布尔项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 += ["Chocolate Spread","Cheese","Butter"] ;

var firstItem = shoppingList[0] ;

shoppingList[4...6] = ["Bananas", "Apples"] ;
//注意： 不可以用下标访问的形式去在数组尾部添加新项

//调用数组的insert(_:atIndex:)方法来在某个具体索引值之前添加数据项：
shoppingList.insert("Maple Syrup", atIndex: 0) ;

//使用removeAtIndex方法来移除数组中的某一项
let mapleSyrup = shoppingList.removeAtIndex(0)
// 索引值为0的数据项被移除
// shoppingList 现在只有6项，而且不包括Maple Syrup
// mapleSyrup常量的值等于被移除数据项的值 "Maple Syrup"


firstItem = shoppingList[0]

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


//数组的遍历
for item in shoppingList {
    print(item)
}

//使用enumerate()方法来进行数组遍历。enumerate()返回一个由每一个数据项索引值和数据值组成的元组。我们可以把这个元组分解成临时常量或者变量来进行遍历：
for (index, value) in shoppingList.enumerate() {
    print("Item \(String(index + 1)): \(value)")
}



//             Set类型语法


//创建和构造一个空的Set
var letters = Set<Character>() ;
print("letters is of type Set<Character> with \(letters.count) items.") ;

letters.insert("a")
// letters 现在含有1个Character类型的值
letters = []
// letters 现在是一个空的Set, 但是它依然是 Set<Character> 类型

//用数组字面量创建集合
var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
// favoriteGenres被构造成含有三个初始值的集合

//一个数组字面量构造一个Set并且该数组字面量中的所有元素类型相同，那么你无须写出Set的具体类型
var favoriteGenres1: Set = ["Rock", "Classical", "Hip hop"] ;

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

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

//可以通过调用Set的remove(_:)方法去删除一个元素，如果该值是该Set的一个元素则删除该元素并且返回被删除的元素值，否认如果该Set不包含该值，则返回nil。另外，Set中的所有元素可以通过它的removeAll()方法删除。
if let removedGenre = favoriteGenres.remove("Rock") {
    print("\(removedGenre)? I'm over it.")
} else {
    print("I never much cared for that.")
}

//使用contains(_:)方法去检查Set中是否包含一个特定的值。
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."

//遍历一个Set
for genre in favoriteGenres {
    print("\(genre)")
}


//完成集合操作
/*
 使用intersect(_:)方法根据两个集合中都包含的值创建的一个新的集合。(共有的创建一个集合)
 使用exclusiveOr(_:)方法根据值在一个集合中但不在两个集合中的值创建一个新的集合。 （除去共有的，创建一个新集合）
 使用union(_:)方法根据两个集合的值创建一个新的集合。 （两个集合合并）
 使用subtract(_:)方法根据不在该集合中的值创建一个新的集合。（除去共有的和对方的）
 
 */

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).sort()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
oddDigits.intersect(evenDigits).sort()
// []
oddDigits.subtract(singleDigitPrimeNumbers).sort()
// [1, 9]
oddDigits.exclusiveOr(singleDigitPrimeNumbers).sort()
// [1, 2, 9]


//字典类型

//创建一个空字典
var namesOfIntegers = [Int : String]()
// namesOfIntegers 是一个空的 [Int: String] 字典

namesOfIntegers[16] = "sixteen"
// namesOfIntegers 现在包含一个键值对
namesOfIntegers = [:]
// namesOfIntegers 又成为了一个 Int, String类型的空字典

//字典字面量    [key 1: value 1, key 2: value 2, key 3: value 3]

var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"] ;

//使用布尔属性isEmpty来快捷的检查字典的count属性是否等于0。
if airports.isEmpty {
    print("The airports dictionary is empty.")
} else {
    print("The airports dictionary is not empty.")
}

//字典中使用下标语法来添加新的数据项。可以使用一个合适类型的键值作为下标索引，并且分配新的合适类型的值：
airports["LHR"] = "London"

//可以使用下标语法来改变特定键对应的值
airports["LHR"] = "London Heathrow"

//updateValue(_:forKey:)函数会返回包含一个字典值类型的可选值。举例来说：对于存储String值的字典，这个函数会返回一个String?或者“可选 String”类型的值。
if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {
    print("The old value for DUB was \(oldValue).")
}

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

//字典遍历
for (airportCode, airportName) in airports {
    print("\(airportCode): \(airportName)")
}

for (airportCode, airportName) in airports.enumerate(){
    
    print("\(airportCode): \(airportName)")
}

//通过访问keys或者values属性，我们也可以遍历字典的键或者值。
for airportCode in airports.keys {
    print("Airport code: \(airportCode)")
}


for airportName in airports.values {
    print("Airport name: \(airportName)")
}

//以直接使用keys或者values属性直接构造一个新数组：
//Swift 的字典类型是无序集合类型。为了以特定的顺序遍历字典的键或值，可以对字典的keys或values属性使用sort()方法。
let airportCodes = Array(airports.keys) ;
let airportNames = Array(airports.values) ;