[swift－day03－集合]

• Swift 语言提供Arrays、Sets和Dictionaries三种基本的集合类型用来存储集合数据。数组（Arrays）是有序数据的集。集合（Sets）是无序无重复数据的集。字典（Dictionaries）是无序的键值对的集。如果创建一个Arrays、Sets或Dictionaries并且把它分配成一个变量，这个集合将会是可变的。这意味着我们可以在创建之后添加更多或移除已存在的数据项，或者改变集合中的数据项。如果我们把Arrays、Sets或Dictionaries分配成常量，那么它就是不可变的，它的大小和内容都不能被改变。

import UIKit

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        //Swift 语言提供Arrays、Sets和Dictionaries三种基本的集合类型用来存储集合数据。数组（Arrays）是有序数据的集。集合（Sets）是无序无重复数据的集。字典（Dictionaries）是无序的键值对的集。如果创建一个Arrays、Sets或Dictionaries并且把它分配成一个变量，这个集合将会是可变的。这意味着我们可以在创建之后添加更多或移除已存在的数据项，或者改变集合中的数据项。如果我们把Arrays、Sets或Dictionaries分配成常量，那么它就是不可变的，它的大小和内容都不能被改变。
        //－－－－－－－－－－－－数组－－－－－－－－－－－－－－－
        //写 Swift 数组应该遵循像Array<Element>这样的形式，其中Element是这个数组中唯一允许存在的数据类型。我们也可以使用像[Element]这样的简单语法
        //创建一个空的数组，构造语法来创建一个由特定数据类型构成的空数组
        var emptyArry = [Int]();//通过构造函数的类型，someInts的值类型被推断为[Int]
        //一个函数参数或者一个已经定义好类型的常量或者变量，我们可以使用空数组语句创建一个空数组，它的写法很简单：[]
        emptyArry.append(3)//现在包涵一个Int值
        emptyArry = [];//emotyArray 现在是空数组 ，但依旧是［Int]类型的
        //Swift 中的Array类型还提供一个可以创建特定大小并且所有数据都被默认的构造方法。我们可以把准备加入新数组的数据项数量（count）和适当类型的初始值（repeatedValue）传入数组构造函数
        var createDouble = [Double](count: 3, repeatedValue: 1.0);//等价于 ［1.0，1.0，1.0］
        //使用加法操作符（+）来组合两种已存在的相同类型数组。新数组的数据类型会被从两个数组的数据类型中推断出来
        var anthonerDouble = Array(count: 3, repeatedValue: 2.0);// anthonerDouble 被推断为 [Double]，等价于 [2.0, 2.0, 2.0]
      
        var twoDouble = createDouble + anthonerDouble;//twoDouble 被推断为 [Double]，等价于 [1.0, 1.0, 1.0, 2.0, 2.0, 2.0]
        print(twoDouble)
        //我们可以使用字面量来进行数组构造，这是一种用一个或者多个数值构造数组的简单方法。字面量是一系列由逗号分割并由方括号包含的数值：[value 1, value 2, value 3]
        
        var exampleArray:[String] = ["peng","lei"];//量被声明为“字符串值类型的数组“，记作[String]。 因为这个数组被规定只有String一种数据结构，所以只有String类型可以在其中被存取。 在这里，exampleArrayt数组由两个String值（"peng" 和"lei"）构造，并且由字面量定义
        //字面量仅仅包含两个String值。匹配了该数组的变量声明（只能包含String的数组），所以这个字面量的分配过程可以作为用两个初始项来构造shoppinglist的一种方式。由于 Swift 的类型推断机制，当我们用字面量构造只拥有相同类型值数组的时候，我们不必把数组的类型定义清楚。 exampleArray的构造也可以这样写：var exampleArray = ["peng","lei"];
        //使用数组的只读属性count来获取数组中的数据项数量
        print(exampleArray.count)
        //使用布尔值属性isEmpty作为检查count属性的值是否为 0 
        if exampleArray.isEmpty{
            print("The exampleArray list is empty.")
        }
        //使用append(_:)方法在数组后面添加新的数据项：
        exampleArray.append("I Love you")
        print(exampleArray)//输出结果["peng", "lei", "I Love you"]
        //使用加法赋值运算符（+=）也可以直接在数组后面添加一个或多个拥有相同类型的数据项
        exampleArray += ["peng"];
        print(exampleArray)//输出结果["peng", "lei", "I Love you", "peng"]
        //直接使用下标语法来获取数组中的数据项，把我们需要的数据项的索引值放在直接放在数组名称的方括号中
        var firstItem = exampleArray[0];
        //用下标来改变某个已有索引值对应的数据值
        exampleArray[0] = "haha";//现在其第一项变为了haha
        //可以利用下标来一次改变一系列数据值，即使新数据和原有数据的数量是不一样的
        exampleArray[1...3] = ["p","l"];
        print(exampleArray)//输出结果["haha", "p", "l"]
        //调用数组的insert(_:atIndex:)方法来在某个具体索引值之前添加数据项
        exampleArray .insert("peng", atIndex: 0)
        print(exampleArray)//["peng", "haha", "p", "l"]
        //使用removeAtIndex(_:)方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项（我们不需要的时候就可以无视它）
        let indexRemove = exampleArray.removeAtIndex(0)
        print(exampleArray,indexRemove)//["haha", "p", "l"] peng
        //数组遍历
        //使用for-in循环来遍历所有数组中的数据项
        for item in exampleArray{
           print(item)
        }
        //同时需要每个数据项的值和索引值，可以使用enumerate()方法来进行数组遍历。enumerate()返回一个由每一个数据项索引值和数据值组成的元组。我们可以把这个元组分解成临时常量或者变量来进行遍历：
        for (index,value) in exampleArray.enumerate(){
         
             print("Item \(index+1):\(value)")
        
        }
        
        
        //－－－－－－－－－－－－－－－－－－－－－－－－－－－－－集合－－－－－－－－－－－－－－－－－－－－－－－－－－－
        //集合(Set)用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次时可以使用集合而不是数组。
        //Swift 中的Set类型被写为Set<Element>，这里的Element表示Set中允许存储的类型，和数组不同的是，集合没有等价的简化形式
        //通过构造器语法创建一个特定类型的空集合
        var letter = Set<Character>()
        //如果上下文提供了类型信息，比如作为函数的参数或者已知类型的变量或常量，我们可以通过一个空的数组字面量创建一个空的Set
        letter.insert("a")//现在包含一个元素
        letter = [] //letter 现在是空的， 但是它依然是 Set<Character> 类型
        //使用数组字面量来构造集合，并且可以使用简化形式写一个或者多个值作为集合元素
        var set1:Set<String> = ["one","two","three"];//变量被声明为“一个String值的集合”，写为Set<String>。由于这个特定的集合含有指定String类型的值，所以它只允许存储String类型值,有三个String类型的初始值("one"，"two"和"three")，并以数组字面量的方式出现
         //由于 Swift 的类型推断功能，如果你想使用一个数组字面量构造一个Set并且该数组字面量中的所有元素类型相同，那么你无须写出Set的具体类型。favoriteGenres的构造形式可以采用简化的方式代替
        var set2 :Set = ["one","two","three"];
        //和数组一样，找出一个Set中元素的数量，可以使用其只读属性count
        print(set1.count)
        //使用布尔属性isEmpty作为一个缩写形式去检查count属性是否为0
        if set1.isEmpty{
          print("hh")
        }
        //调用Set的insert(_:)方法来添加一个新元素
        set1.insert("four")
        //通过调用Set的remove(_:)方法去删除一个元素，如果该值是该Set的一个元素则删除该元素并且返回被删除的元素值，否则如果该Set不包含该值，则返回nil。另外，Set中的所有元素可以通过它的removeAll()方法删除
        let removeSet = set1.remove("four");
        //for-in循环中遍历一个Set中的所有值。
        for item in set1{
         
            print(item)
        
 }
        //Swift 的Set类型没有确定的顺序，为了按照特定顺序来遍历一个Set中的值可以使用sort()方法，它将根据提供的序列返回一个有序集合.
        for item in set1.sort(){
            print("\(item)");
        }
        //集合的之间的几种操作
//        使用intersect(_:)方法根据两个集合中都包含的值创建的一个新的集合。
//        使用exclusiveOr(_:)方法根据在一个集合中但不在两个集合中的值创建一个新的集合。
//        使用union(_:)方法根据两个集合的值创建一个新的集合。
//        使用subtract(_:)方法根据不在该集合中的值创建一个新的集合
        
        let oneSet: Set = [0,1,2];
        let twoSet: Set = [2,3,4,5,6];
        let threeSet:Set = [5,6,7,8,9];
        print(oneSet.union(twoSet).sort())//输出[0, 1, 2, 3, 4, 5, 6]
        print(oneSet.intersect(twoSet).sort())//输出[2]
        print(twoSet .subtract(threeSet).sort())//输出[2, 3, 4]
        print(twoSet.exclusiveOr(threeSet).sort())//输出[2, 3, 4, 7, 8, 9]
        //包含关系
//        使用“是否相等”运算符(==)来判断两个集合是否包含全部相同的值。
//        使用isSubsetOf(_:)方法来判断一个集合中的值是否也被包含在另外一个集合中。
//        使用isSupersetOf(_:)方法来判断一个集合中包含另一个集合中所有的值。
//        使用isStrictSubsetOf(_:)或者isStrictSupersetOf(_:)方法来判断一个集合是否是另外一个集合的子集合或者父集合并且两个集合并不相等。
//        使用isDisjointWith(_:)方法来判断两个集合是否不含有相同的值(是否没有交集)。
        let fourSet : Set = [0,1,2,3,4,5,6,7,8,9];
        print(oneSet == twoSet)//false
        print(oneSet.isSubsetOf(fourSet))//true
        print(oneSet.isSupersetOf(oneSet))//true
        print(oneSet.isStrictSubsetOf(fourSet))//true
        print(oneSet.isDisjointWith(fourSet))//false
        
        //------------------------字典－－－－－－－－－－－－－－
        //Swift 的字典使用Dictionary<Key, Value>定义，其中Key是字典中键的数据类型，Value是字典中对应于这些键所存储值的数据类型,也可以用[Key: Value]这样快捷的形式去创建一个字典类型。虽然这两种形式功能上相同，但是后者是首选
        //可以像数组一样使用构造语法创建一个拥有确定类型的空字典：
        var dict1 = [Int:String]()//一个空的 [Int: String] 字典
        //如果上下文已经提供了类型信息，我们可以使用空字典字面量来创建一个空字典，记作[:]（中括号中放一个冒号）：
        dict1[16] = "peng";//现在包含一个键值对
        dict1 = [:];//dict 又成为了一个 [Int: String] 类型的空字典
        //可以使用字典字面量来构造字典，这和我们刚才介绍过的数组字面量拥有相似语法。字典字面量是一种将一个或多个键值对写作Dictionary集合的快捷途径。
        //格式[key 1: value 1, key 2: value 2, key 3: value 3]
        var stringDic:[String:String] = ["one":"1","two":"2"];//字典语句包含了两个String: String类型的键值对
        //和数组一样，我们在用字典字面量构造字典时，如果它的键和值都有各自一致的类型，那么就不必写出字典的类型,stringDic= ["one":"1","two":"2"],因为这个语句中所有的键和值都各自拥有相同的数据类型，Swift 可以推断出Dictionary<String, String>是airports字典的正确类型。
        //和上面两个数据类型一样，可以通过字典的只读属性count来获取某个字典的数据项数量，使用布尔属性isEmpty来快捷地检查字典的count属性是否等于0,这里不再举例
        //可以在字典中使用下标语法来添加新的数据项。可以使用一个恰当类型的键作为下标索引，并且分配恰当类型的新值
        stringDic["three"] = "3";//此时增加了一个数据项
        //也可以使用下标语法来改变特定键对应的值
        stringDic["three"] = "san";//此时“three”对应的值改为了san
        //作为另一种下标方法，字典的updateValue(_:forKey:)方法可以设置或者更新特定键对应的值。就像上面所示的下标示例，updateValue(_:forKey:)方法在这个键不存在对应值的时候会设置新值或者在存在时更新已存在的值。和上面的下标方法不同的，updateValue(_:forKey:)这个方法返回更新值之前的原值。这样使得我们可以检查更新是否成功。
        
        //updateValue(_:forKey:)方法会返回对应值的类型的可选值。举例来说：对于存储String值的字典，这个函数会返回一个String?或者“可选 String”类型的值。
        
        //如果有值存在于更新前，则这个可选值包含了旧值，否则它将会是nil
        if let oldValue = stringDic.updateValue("3", forKey: "three"){
        
           print("the old value for was \(oldValue)")
        }
        
        //还可以使用下标语法来通过给某个键的对应值赋值为nil来从字典里移除一个键值对
        stringDic["four"] = "4";
        stringDic["four"] = nil;//“four”对应的键值对被移除了
        //removeValueForKey(_:)方法也可以用来在字典中移除键值对。这个方法在键值对存在的情况下会移除该键值对并且返回被移除的值或者在没有值的情况下返回nil
        if let removedValue = stringDic.removeValueForKey("three"){
        
            print("The  removed name is \(removedValue)");//The  removed name is 3
        }
        //for-in循环来遍历某个字典中的键值对。每一个字典中的数据项都以(key, value)元组形式返回，并且我们可以使用临时常量或者变量来分解这些元组
        for(strCode,stringName) in stringDic{
        
            print("\(strCode):\(stringName)")//one:1  two:2
        }
        //通过访问keys或者values属性，我们也可以遍历字典的键或者值
        for strcode in stringDic.keys{
          
            print("strcode = \(strcode)")//strcode = one  strcode = two
        }
        for stringName in stringDic.values{
         
            print("stringName = \(stringName)")//  stringName = 1  stringName = 2

        
        }
        //Swift 的字典类型是无序集合类型。为了以特定的顺序遍历字典的键或值，可以对字典的keys或values属性使用sort()方法
        var stringDic2:[String:String] = ["one":"1","two":"2","three":"3","four":"4","five":"5","six":"6","seven":"7","eight":"8","1":"1","2":"2","3":"3"];
        print(stringDic2.values.sort())//["1", "1", "2", "2", "3", "3", "4", "5", "6", "7", "8"],可见输出结果按升序出来的
        
        
        // Do any additional setup after loading the view, typically from a nib.
    }
   
    
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }


}