/*数组（Arrays*）*/
    //创建数组
    var someInts = [Int]()
    print("someInts is of type [Int] with \(someInts.count) items.") // 打印 "someInts is of type [Int] with 0 items."
    
    var threeDoubles = Array(repeating: 0.0, count: 3)
    
    //通过两个数组相加创建一个数组
    var anotherThreeDoubles = Array(repeating: 2.5, count: 3)
    
    var sixDoubles = threeDoubles + anotherThreeDoubles
    
    print(sixDoubles)
    
    //访问和修改数组
    
    var shoppingList = ["Eggs", "Milk"]
    
    print("The shopping list contains \(shoppingList.count) items.")
    
    if shoppingList.isEmpty {
        print("The shopping list is empty.")
    } else {
        print("The shopping list is not empty.")
    }
    
    //使用append(_:)方法在数组后面添加新的数据项
    shoppingList.append("Flour")
    
    //使用（+=）在数组后面添加数据项（相同类型）
    shoppingList += ["Baking Powder"]
    
    //使用下标获取数组的数据项
    var firstItem = shoppingList[0]
    
    //通过下标来改变数据项值
    shoppingList[0] = "Six eggs"
    print(shoppingList)
    shoppingList[1...2] = ["Bananas", "Apples"]
    
    //调用数组的 insert(_:at:) 方法来在某个具体索引值之前添加数据项:
    shoppingList.insert("Maple Syrup", at: 0)
    
    //remove(at:)删除某个元素
   shoppingList.remove(at: 0)
    
    //删除最后一项
    shoppingList.removeLast()
    //删除所有
    // shoppingList.removeAll()
    
    //遍历数组
    for item in shoppingList {
        print(item)
    }
    
    //如果我们同时需要每个数据项的值和索引值,可以使用 enumerated() 方法来进行数组遍历。 enumerated() 返回 一个由每一个数据项索引值和数据值组成的元组。我们可以把这个元组分解成临时常量或者变量来进行遍历:
    for (index,value) in shoppingList.enumerated() {
        print("Item \(String(index + 1)):\(value)")
    }
    
    
    /************************集合*********************************/
    
    // 集合(Set)用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次 时可以使用 合而不是数组。
    //集合类型的哈希值 
    //一个类型为了存储在集合中,该类型必须是可哈希化的--也就是说,该类型必须提供一个方法来计算它的哈希值。一个哈希值是 Int 类型的,相等的对象哈希值必须相同,比如 a==b ,因此必须 a.hashValue == b.hashValue。
    
    //创建和构造一个空的集合
    var letters = Set<Character>()
    print("letters is of type Set<Character> with \(letters.count) items.")
    letters.insert("a")
    
    //用数组字面量创建集合
    var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
    print(favoriteGenres)
    
    
    //访问和修改一个集合
    //你可以通过 Set 的属性和方法来访问和修改一个 Set 。
    print("I have \(favoriteGenres.count) favorite music genres.")
    
    //使用布尔属性 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")
    
    //调用 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.")
        
    }
    
    //遍历集合
    for genre in favoriteGenres {
        print("\(genre)")
    }
    
    //Swift 的 Set 类型没有确定的顺序,为了按照特定顺序来遍历一个 Set 中的值可以使用 sorted() 方法,它将返回一个有序数组,这个数组的元素排列顺序由操作符'<'对元素进行比较的结果来确定.
    for genre in favoriteGenres.sorted() {
        print("\(genre)")
    }
    
    
    //集合操作
    //使用 intersection(_:) 方法根据两个集合中都包含的值创建的一个新的集合。
    //使用 symmetricDifference(_:) 方法根据在一个集合中但不在两个集合中的值创建一个新的集合。
    //使用 union(_:) 方法根据两个集合的值创建一个新的集合。
    //使用 subtracting(_:) 方法根据不在该集合中的值创建一个新的集合。
    
    let oldDigts:Set = [1,3,5,7,9]
    let evenDigts:Set = [0,2,4,6,8]
    let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]
    
    oldDigts.union(evenDigts).sorted()
    oldDigts.subtracting(singleDigitPrimeNumbers).sorted()
    oldDigts.symmetricDifference(singleDigitPrimeNumbers).sorted()
    print(oldDigts.union(evenDigts).sorted())
    print(oldDigts.subtracting(singleDigitPrimeNumbers).sorted())
    print(oldDigts.symmetricDifference(singleDigitPrimeNumbers).sorted())
    
    
    //集合成员关系和相等
    //使用“是否相等”运算符( == )来判断两个集合是否包含全部相同的值。
    //使用 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
    
    //字典
    //字典类型简化语法:Swift 的字典使用 Dictionary<Key, Value> 定义,其中 Key 是字典中键的数据类型, Value 是字典中对应于这些 键所存储值的数据类型。
    
    //创建字典
    var namesOfIntegers = [NSInteger: String]()
    // namesOfIntegers 是一个空的 [Int: String] 字典
    
    namesOfIntegers[16] = "sixteen"
    // namesOfIntegers 现在包含一个键值对
    
    namesOfIntegers = [:]
    // namesOfIntegers 又成为了一个 [Int: String] 类型的空字典
    
    //用字典字面量创建字典
    var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
    
    //访问和修改字典
    //通过字典的只读属性 count 来获取某个字典的数据项数量:
    print("The dictionary of airports contains \(airports.count) items.")
    // 打印 "The dictionary of airports contains 2 items."(这个字典有两个数据项)
    
    //字典的 updateValue(_:forKey:) 方法可以设置或者更新特定键对应的值。返回跟新之前的值
    if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {
        print("The old value for DUB was \(oldValue).")
    }
    print(airports)
    
    //字典遍历
    for (airportCode, airportName) in airports {
        print("\(airportCode): \(airportName)")
    }
    
    //通过访问keys或者values属性,我们也可以遍历字典的键或者值:
    for airportCode in airports.keys {
        print("Airport code: \(airportCode)")
    }
    
    for airportName in airports.values {
        print("Airport name: \(airportName)")
    }