• swift Array Set Dictionary

    1、数组(Array):

    import Foundation
    
    //数组
    
    //新建一个数组
    var array1 = [Int]() //空数组  里面没有元素
    print(array1.count)
    array1.append(3)  //添加元素
    print(array1.count)
    array1 = []     //清空数组
    print(array1.count)
    
    //新建一个带有默认值的数组
    var array2 = [Float](count: 5, repeatedValue: 2.11)
    print(array2)
    var array3 = [Float](count: 2, repeatedValue: 3.22)
    print(array3)
    var array23 = array2 + array3    //合并两个类型相同的数组
    print(array23)
    
    //新建指定数值的数组
    var array4 : [String] = ["value1", "value2", "value3"]
    print(array4)
    
    
    //访问和修改数组值
    var array5 = [String]()
    if array5.count == 0 {
        print("array5 is empty")
    }
    if array5.isEmpty {
        print("array5 is empty")
    }
    
    //添加数据项
    array5.append("v1")
    array5 += ["v2"]
    array5 += ["v3", "v4"]
    print(array5)
    print(array5[0])
    
    array5[0] = "v111" //改变值
    print(array5)
    array5[1...3] = ["v123"]  //3项 替换为1项
    print(array5)
    
    array5.insert("v-insert", atIndex: 1) // 在某个具体索引之前添加数据项
    print(array5)
    
    array5.removeAtIndex(2) // 按索引移除某一项
    print(array5)
    
    //array5.removeFirst()   移除第一项
    //array5.removeLast()   移除最后一项
    array5.removeAll()   //移除所有
    print(array5)
    
    
    //遍历数组
    var array6 = [1, 2, 3, 4, 5, 6]
    for item in array6 {
        print(item)
    }
    
    for (index, value) in array6.enumerate() {
        print("index:\(index),value:\(value)")
    }
    

    输出:

    0
    1
    0
    [2.11, 2.11, 2.11, 2.11, 2.11]
    [3.22, 3.22]
    [2.11, 2.11, 2.11, 2.11, 2.11, 3.22, 3.22]
    ["value1", "value2", "value3"]
    array5 is empty
    array5 is empty
    ["v1", "v2", "v3", "v4"]
    v1
    ["v111", "v2", "v3", "v4"]
    ["v111", "v123"]
    ["v111", "v-insert", "v123"]
    ["v111", "v-insert"]
    []
    1
    2
    3
    4
    5
    6
    index:0,value:1
    index:1,value:2
    index:2,value:3
    index:3,value:4
    index:4,value:5
    index:5,value:6
    Program ended with exit code: 0

    2、集合(Set)

    //set   集合
    
    //用来存储相同数据类型,但是没有确定顺序,元素的值不能相同
    var set1 = Set<String>()
    set1.insert("value1")
    set1.insert("value2")
    print(set1)
    set1.insert("value1")
    print(set1)
    
    set1 = []   //置空
    print(set1)
    
    //用数组创建集合
    var set2 : Set<String> = ["set21", "set22", "set23"]
    var set3 : Set<String> = ["set211", "set444", "set222", "set233", "set222"]
    print(set2)
    print(set3)
    
    //set3.isEmpty
    //set3.count   //这两个和数组一样
    
    set3.insert("set1")
    print(set3)
    
    set3.remove("set1")
    /*
    你可以通过调⽤ Set  的 remove(_:)  ⽅法去删除⼀个元素,如果该值是该 Set  的⼀个元素则删
    除该元素并且返回被删除的元素值,否认如果该 Set  不包含该值,则返回 nil  。另
    外, Set  中的所有元素可以通过它的 removeAll()  ⽅法删除。
    */
    
    var isContain = set3.contains("set211")
    
    //遍历一个set
    for item in set3 {
        print(item)
    }
    //排序后输出
    for item in set3.sort() {
        print(item)
    }
    
    
    
    //基本集合操作
    var a : Set<Int> = [1, 3, 4, 6, 7, 8, 9]
    var b : Set<Int> = [2, 4, 5, 8]
    print(a)
    print(b)
    //交集
    print(a.intersect(b))
    //并集
    print(a.union(b))
    //a-b
    print(a.subtract(b))
    //并集-交集
    print(a.exclusiveOr(b))
    
    
    
    //集合成员关系和相等
    var c : Set<Int> = [1, 3]
    var d : Set<Int> = [1, 3]
    if c == d {
        print("c和d这两个集合相等")
    }
    
    if c.isSubsetOf(a) {
        print("a包含c")
    }
    if a.isSupersetOf(d) {
        print("a包含d")
    }
    if c.isDisjointWith(b) {
        print("c与b没有交集")
    }
    if c.isStrictSubsetOf(a) {
        print("c是a的子集合")
    }
    
    
    /*
    /// Returns true if the set is a subset of a finite sequence as a `Set`.
    @warn_unused_result
    public func isSubsetOf<S : SequenceType where S.Generator.Element == Element>(sequence: S) -> Bool
    /// Returns true if the set is a subset of a finite sequence as a `Set`
    /// but not equal.
    @warn_unused_result
    public func isStrictSubsetOf<S : SequenceType where S.Generator.Element == Element>(sequence: S) -> Bool
    */
    //看上面定义可知  这两个的区别是isStrictSubsetOf  两个集合不能相等  isSubsetOf可以相等
    if c.isSubsetOf(d) {
        print("--")
    }
    if c.isStrictSubsetOf(d){
        print("++")
    }

    集合操作图:



    输出:

    ["value1", "value2"]
    ["value1", "value2"]
    []
    ["set22", "set21", "set23"]
    ["set211", "set222", "set233", "set444"]
    ["set1", "set211", "set222", "set233", "set444"]
    set211
    set222
    set233
    set444
    set211
    set222
    set233
    set444
    [4, 9, 6, 7, 3, 1, 8]
    [5, 2, 4, 8]
    [4, 8]
    [2, 4, 9, 6, 7, 5, 3, 1, 8]
    [9, 6, 7, 3, 1]
    [2, 9, 6, 7, 5, 3, 1]
    c和d这两个集合相等
    a包含c
    a包含d
    c与b没有交集
    c是a的子集合
    --
    Program ended with exit code: 0

    3、字典

    //字典
    
    /*
    Swift 的字典使⽤ Dictionary<Key, Value>  定义,其中 Key  是字典中键的数据类型,Value是字典中对应于这些键所存储值的数据类型。
    注意: ⼀个字典的 Key  类型必须遵循 Hashable  协议,就像 Set  的值类型。
    我们也可以⽤ [Key: Value]  这样快捷的形式去创建⼀个字典类型。虽然这俩种形式功能上相同,但是后者是⾸选
    */
    
    //两种创建方式
    var dict1 = [String : String]()
    var dict2 = Dictionary<String, String>()
    print(dict1)
    print(dict2)
    dict1["key1"] = "value1"
    print(dict1)
    dict1 = [:]     //置空
    print(dict1)
    
    var dict3 : [String : String] = ["key1":"value1", "key2":"value2", "key3":"value3"]
    print(dict3)
    //定义dict3的时候   [String : String]  可以省略
    
    //字典基本操作
    //dict3.isEmpty
    //dict3.count   判断是否为空
    
    //增加
    dict3["key4"] = "value4"
    print(dict3)
    
    //修改
    dict3["key4"] = "value4444444"
    print(dict3)
    dict3.updateValue("valueNew4", forKey: "key4")
    print(dict3)
    
    //删除
    dict3.removeValueForKey("key4")
    print(dict3)
    
    //遍历
    for (key, value) in dict3 {
        print("\(key) : \(value)")
    }
    
    for key in dict3.keys {
        print(key)
    }
    for value in dict3.values {
        print(value)
    }
    
    for key in dict3.keys.sort() {
        print(dict3[key]!)
    }

    输出:

    [:]
    [:]
    ["key1": "value1"]
    [:]
    ["key1": "value1", "key3": "value3", "key2": "value2"]
    ["key1": "value1", "key4": "value4", "key2": "value2", "key3": "value3"]
    ["key1": "value1", "key4": "value4444444", "key2": "value2", "key3": "value3"]
    ["key1": "value1", "key4": "valueNew4", "key2": "value2", "key3": "value3"]
    ["key1": "value1", "key2": "value2", "key3": "value3"]
    key1 : value1
    key2 : value2
    key3 : value3
    key1
    key2
    key3
    value1
    value2
    value3
    value1
    value2
    value3
    Program ended with exit code: 0




    展开全文
  • ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★➤微信公众号:山青咏芝(shanqingyongzhi)➤博客园地址:山青咏芝(https://www.cnblogs.com/strengthen/)➤GitHub地址:...

    ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
    ➤微信公众号:山青咏芝(shanqingyongzhi)
    ➤博客园地址:山青咏芝(https://www.cnblogs.com/strengthen/ 
    ➤GitHub地址:https://github.com/strengthen/LeetCode
    ➤原文地址:https://www.cnblogs.com/strengthen/p/10176725.html 
    ➤如果链接不是山青咏芝的博客园地址,则可能是爬取作者的文章。
    ➤原文已修改更新!强烈建议点击原文地址阅读!支持作者!支持原创!
    ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

    直接上代码,给你个眼神,自己领悟!

     1 //Set排序
     2 let stringSet1 = Set(["car", "boat", "bike", "toy"])
     3 let stringArray1 = stringSet1.sorted()
     4 print(stringArray1)
     5 // will print ["bike", "boat", "car", "toy"]
     6 
     7 //Set去除元素第一位不为b字母的元素
     8 let stringSet2 = Set(arrayLiteral: "car", "boat", "car", "bike", "toy") 
     9 let stringArray2 = stringSet2.filter { $0.characters.first != "b" }
    10 print(stringArray2)
    11 // may print ["car", "toy"]
    12 
    13 //Set<Int>转换为[String]
    14 let intSet3 = Set([1, 3, 5, 2]) 
    15 //方法一:flatMap
    16 let stringArray3 = intSet3.flatMap { String($0) }
    17 print(stringArray3)
    18 //方法二:Array
    19 let stringArray4 = Array(intSet3)
    20 print(stringArray4)
    21 // may print ["5", "2", "3", "1"]
    22 
    23 //Set<Int>转换为[Int]
    24 let intSet5 = Set([1, 3, 5, 2])
    25 let intArray5 = intSet5.map { $0 }
    26 print(intArray5)
    27 // may print [5, 2, 3, 1]

     

    转载于:https://www.cnblogs.com/strengthen/p/10176725.html

    展开全文
  • swift Set(集合)

    2016-01-19 18:35:09
    //创建集合    //通过构造器语法创建一个特定类型的空集合;...var set = SetString>()   println("set have \(set.count)")    set.insert("name")  //现在含有1个string类型的值

    //创建集合

            

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

            var set = Set<String>()

            println("set have \(set.count)")

            

            set.insert("name")

            //现在含有1string类型的值

            

            set = []

            //set现在是一个空的Set, 但是它依然是 Set<string> 类型

            

            var setStringSet: Set<String> = ["1", "2", "3"]

            // setStringSet被构造成含有三个初始值string类型的集合

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

            

            

    //        访问和修改一个Set

            //使用布尔属性isEmpty作为一个缩写形式去检查count属性是否为0:

            if setStringSet.isEmpty {

                println("set为空")

            } else {

                println("set不为空")

            }

            

            //你可以通过调用Setinsert(_:)方法来添加一个新元素:

            setStringSet.insert("Jazz")

            

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

            if let removedSet = setStringSet.remove("Rock") {

                println("\(removedSet)")

            } else {

                println("much")

            }

            

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

            if setStringSet.contains("1") {

                print("不在set")

            } else {

                print("in here.")

            }

            

            //for-in循环中遍历一个Set中的所有值。

            for setstringSet in setStringSet {

                print("1-\(setstringSet)")

            }

            

         

    //        完成集合操作

    //        

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

    //        

    //        

    //        基本集合操作

    //        

    //        下面的插图描述了两个集合-ab-以及通过阴影部分的区域显示集合各种操作的结果。

    //        

    //        

    //        

    //        使用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]

            

    //        集合成员关系和相等

    //        

    //        下面的插图描述了三个集合-a,bc,以及通过悬浮区域表述集合间共享的元素。Set aSetb的父集合,因为a包含了b中所有的元素,相反的,Set ba的子集合,因为属于b的元素也被a包含。Set bSet c彼此不关联,因为它们之间没有共同的元素。

            

            

            

    //        使用是否等运算符(==)来判断两个集合是否包含全部相同的值。

    //        使用isSubsetOf(_:)方法来判断一个集合中的值是否也被包含在另外一个集合中。

    //        使用isSupersetOf(_:)方法来判断一个集合中包含的值是另一个集合中所有的值。

    //        使用isStrictSubsetOf(_:)或者isStrictSupersetOf(_:)方法来判断一个集合是否是另外一个集合的子集合或者父集合并且和特定集合不相等。

    //        使用isDisjointWith(_:)方法来判断两个结合是否不含有相同的值。

            let houseAnimals: Set = ["

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

    一:概念
    Swift 语言提供 Arrays 、 Sets 和 Dictionaries 三种基本的集合类型用来存储集合数据。

    1. 数组(Arrays)是有序 数据的集。
    2. 集合(Sets)是无序无重复数据的集。
    3. 字典(Dictionaries)是无序的键值对的集。

    这里写图片描述
    Swift 的 Arrays 、 Sets 和 Dictionaries 类型被实现为泛型集合。更多关于泛型类型和集合

    二:集合的可变性
    如果创建一个 Arrays 、 Sets 或 Dictionaries 并且把它分配成一个变量,这个集合将会是可变的。
    如果我们把 Arrays 、 Sets 或Dictionaries分配成常量,那么它就是不可变的,它的大小不能被改变。(好习惯:不需要改变集合大小的时候创建不可变集合)


    三:数组

    • 有序

    概念:数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。

    数组的简单语法

    写 Swift 数组应该遵循像 Array<Element> 这样的形式,其中 Element 是这个数组中唯一允许存在的数据类 型。我们也可以使用像 [Element] 这样的简单语法。尽管两种形式在功能上是一样的,但是推荐较短的那种,而 且在本文中都会使用这种形式来使用数组。

    创建数组:

    /*  创建数组**/
    //1:创建一个空数组
    //(1)通过构造函数的类型, someInts 的值类型被推断为 [Int]
    var someInts1 = [Int]()//[]
    //(2)使用空数组语句创建一个空数组,它的写法很简单: []
    var someInts2 = []//()仍然是 [Int] 类型的
    
    //2:创建一个带有默认值的数组
    var threeDoubles = [Double](count: 3, repeatedValue: 1.2)
    var threeDoubles2 = [Double](count: 3, repeatedValue: 0.9)
    var sixDouble = threeDoubles + threeDoubles2
    
    ///3:字面量构造数组
    var foodList = ["Egg","Milk"]

    数组的访问和修改

    /*  访问和修改数组**/
    //1:只读属性count访问数组个数
    foodList.count
    
    //2:布尔值属性 isEmpty 作为检查数组是否为空(count==0)
    if foodList.isEmpty{
    
    }
    //3: append(_:) 方法在数组后面添加新的数据项
    foodList.append("orange")
    
    //4:加法赋值运算符( += )也可以直接在数组后面添加一个或多个拥有相同类型的数据项
    foodList += ["Chocolate Spread", "Cheese", "Butter"]
    
    //5:访问数组下标对应元素
    var firstItem = foodList[0]
    
    //6:修改数组某个数据
    foodList[1] = "my Milk"
    
    //7:修改数组多条数据
    foodList.count //判断下范围,避免下行代码越界
    foodList[4...5]=["Bananas","Apples","abc","egg"]
    
    //8:修改数组元素
    foodList.insert("pear", atIndex: 0)
    foodList.removeAtIndex(0)
    foodList.removeFirst()
    foodList.removeFirst(2)
    foodList.removeLast()
    foodList.count
    let range = foodList.startIndex.advancedBy(0)..<foodList.endIndex
    foodList.removeRange(range)
    foodList.count
    foodList.removeAll()

    数组遍历

    /**数组的遍历*/
    //1:直接遍历
    for item in foodList{
    print(item)
    }
    //2:带索引值遍历
    for(index,value)in foodList.enumerate(){
    print("索引 \(String(index+1)):\(value) ")
    }

    四:集合

    • 无序不重复

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

    集合类型的哈希值 :

    一个类型为了存储在集合中,该类型必须是可哈希化的–也就是说,该类型必须提供一个方法来计算它的哈希 值。一个哈希值是 Int 类型的,相等的对象哈希值必须相同,比如 a==b ,因此必须 a.hashValue == b.hashValu e。

    Swift 的所有基本类型(比如 String , Int , Double 和 Bool )默认都是可哈希化的,可以作为集合的值的类型或 者字典的键的类型。没有关联值的枚举成员值(在枚举有讲述)默认也是可哈希化的。

    注意: 你可以使用你自定义的类型作为集合的值的类型或者是字典的键的类型,但你需要使你的自定义类型符合 Swift 标准库中的 Hashable 协议。符合 Hashable 协议的类型需要提供一个类型为 Int 的可读属性 hashValue 。由类 型的 hashValue 属性返回的值不需要在同一程序的不同执行周期或者不同程序之间保持相同。因为 Hashable 协议符合 Equatable 协议,所以符合该协议的类型也必须提供一个”是否相等”运算符( == )的实 现。这个 Equatable 协议要求任何符合 == 实现的实例间都是一种相等的关系。也就是说,对于 a,b,c 三个值来 说, == 的实现必须满足下面三种情况:
    • a == a (自反性)
    • a == b 意味着 b == a (对称性)
    • a == b && b == c 意味着 a == c (传递性)

    创建集合

    /*创建集合{}**/
    //1:创建空集合(没有简方法)
    var letters = Set<Character>()//[]
    
    //2:通过数组方式修改成空集合
    letters.insert("q")
    letters = []
    
    //3:用数组字面量创建集合
    var mySet:Set<String> = ["apple","pear","banana","app"]
    let mySet1:Set<Int> = [1,2,3]
    let mySet2:Set = [1.3,3.2,4.3,5.6]//Set类型必须显式声明,否则是数组

    访问和修改一个集合

    /**访问和修改一个集合**/
    //1:只读属性count访问
    mySet.count
    //2:布尔属性 isEmpty
    if mySet.isEmpty{
    
    }
    //3:添加新元素
    mySet.insert("cocoa")
    //4:删除元素
    mySet.remove("coffe")//删除不存在的元素,返回nil,而不是崩溃
    //5:包含特定值
    mySet.contains("cocoa")

    遍历集合

    /**遍历一个集合**/
    //1:直接遍历(无序)
    for item in mySet{
    print(item)
    }
    //2:排序遍历(按字母顺序)
    for item in mySet.sort(){
    print(item)
    }

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

    这里写图片描述

    1. 使用 intersect(_:) 方法根据两个集合中都包含的值创建的一个新的集合。
    2. 使用 exclusiveOr(_:) 方法根据在一个集合中但不在两个集合中的值创建一个新的集合。
    3. 使用 union(_:) 方法根据两个集合的值创建一个新的集合。
    4. 使用 subtract(_:) 方法根据不在该集合中的值创建一个新的集合。
    /**集合操作 **/
    let oddDigits:Set = [1,3,5,7,9]
    let evenDigits:Set = [0,2,4,6,8]
    let singleDigit:Set = [2,3,5,7]
    
    //交
    oddDigits.intersect(evenDigits).sort()
    //并
    oddDigits.union(evenDigits).sort()
    //只在一个中,而不在俩个中
    oddDigits.exclusiveOr(evenDigits).sort()
    //完全不在后者中
    oddDigits.subtract(evenDigits).sort()

    集合成员关系和相等
    这里写图片描述

    1. 使用“是否相等”运算符( == )来判断两个集合是否包含全部相同的值。
    2. 使用 isSubsetOf(_:) 方法来判断一个集合中的值是否也被包含在另外一个集合中。
    3. 使用 isSupersetOf(_:) 方法来判断一个集合中包含另一个集合中所有的值。
    4. 使用 isStrictSubsetOf(:) 或者 isStrictSupersetOf(:) 方法来判断一个集合是否是另外一个集合的子集合 或者父集合并且两个集合并不相等。
    5. 使用 isDisjointWith(_:) 方法来判断两个集合是否不含有相同的值。
    /**集合间的关系**/
    let me:Set = ["wo"]
    let brother:Set = ["ni"]
    let father:Set = ["ni","wo","ta"]
    
    //判断两个集合是否包含全部相同的值
    me == brother
    //判断一个集合中的值是否也被包含在另外一个集合中
    me.isSubsetOf(father)
    father.isSupersetOf(brother)
    //判断一个集合是否是另外一个集合的子集合 或者父集合并且两个集合并不相等。
    me.isStrictSubsetOf(father)
    father.isStrictSupersetOf(brother)
    //判断两个集合是否不含有相同的值。
    me.isDisjointWith(brother)

    五:字典

    • 无序
    • 键值对

    概念:字典是一种存储多个相同类型的值的容器。每个值(value)都关联唯一的键(key),键作为字典中的这个值数 据的标识符。和数组中的数据项不同,字典中的数据项并没有具体顺序。我们在需要通过标识符(键)访问数据 的时候使用字典,这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。

    Swift 的字典类型是无序集合类型。为了以特定的顺序遍历字典的键或值,可以对字典的keys  或 values 属性使 用  sort()方法。

    字典的创建

    
    /** 字典的创建 **/
    
    //简洁语法
    //[key:value]
    
    //1:创建一个空字典
    var names = [Int:String]()//[:]
    names[16] = "sixteen"//赋值
    names = [:]//已知类型,可清空字典
    
    //2:用字典字面量创建字典
    //简短方式
    var airPorts = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
    //常规方式
    var airPorts1:Dictionary = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
    var airPorts2:[ String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
    

    字典的访问和修改

    /**访问和修改字典*/
    //1:只读属性count
    airPorts.count
    //2:布尔属性 isEmpty 
    if airPorts.isEmpty{
    
    }
    //3:以键值对形式添加字典元素
    airPorts["LHR"] = "London"
    
    //4:按键修改值
    airPorts["LHR"] = "London Heathrow"
    
    //5:updateValue(_:forKey:) 这个方法返回更新值之前的原值(旧值)
    //我们可以根据这个条件来判断 是否更新成功
    if let oldAirPort = airPorts.updateValue("AAA", forKey:"LHR"){
        print(oldAirPort)
        print(airPorts["LHR"])//现在是AAA而且可选
    }
    
    //如果有值存在于更新前,则这个可选值包含了旧值,否则它将会是 nil 。
    if let oldAirPort2 = airPorts.updateValue("", forKey:"LM"){
        print(oldAirPort2)
        print(airPorts["LM"])
    }
    
    //6:移除键值对
    //通过给某个键的对应值赋值为 nil 
    airPorts["LM"]=nil
    print(airPorts)
    
    //通过移除某个键
    airPorts.removeValueForKey("LHR")
    print(airPorts)
    
    //airPorts.removeAll()

    字典的遍历

    /**字典遍历*/
    //通用
    for (code,name)in airPorts{
    print("机场简写:\(code):机场名字:\(name)")
    }
    
    //访问keys或者value属性
    for airPortCode in airPorts.keys{
    print(airPortCode)
    }
    
    for airPortName in airPorts.values{
    print(airPortName)
    }

    字典向数组的转化

    /**字典的键值向数组的转化*/
    let airportCodes = [String](airPorts.keys)
    let airportValues = [String](airPorts.values)
    展开全文
  • Swift3-集合类型

    2017-03-03 16:13:13
    一、引言Swift中提供了3种集合类型,Array数据类型,Set集合类型,Dictionary字典类型。 Array用于存放一组有序的数据,数据角标从0开始一次递增; Set用于存放一组无序的数据,数据不可以重复; Dictionary也...

    一、引言

    Swift中提供了3种集合类型,Array数据类型,Set集合类型,Dictionary字典类型。

    Array用于存放一组有序的数据,数据角标从0开始一次递增;
    Set用于存放一组无序的数据,数据不可以重复;
    Dictionary也用于存放一组无序的数据,只是其是按照键值对的方式存储,键值必须唯一。

    这里借用官方文档中的一张图来表示3种集合类型的特点:
    这里写图片描述

    二、Array类型

    Array通常也被称为数组,Swift是一种类型安全语言,其中的Array类型也必须确定其元素的类型,声明数组类型有两种方法,示例如下:

    //将数组声明为Int类型值集合的数组
    var array1:[Int]
    var array2:Array<Int>
    //创建空数组
    array1 = []
    array2 = Array()

    数组对象如果通过var变量也接收,则其为可变的数组,可以通过append方法来追加元素,示例如下:

    //向数组中追加元素
    array1.append(3)    //[3]

    在创建数组时,也可以对数组进行初始化,示例如下:

    //创建数组[0,0,0]
    var array3 = [Double](repeating: 0, count: 3)
    //创建数组[2.5,2.5,2.5]
    var array4 = Array(repeating: 2.5, count: 3)
    //数组可以使用+号直接进行追加 [0,0,0,2.5,2.5,2.5]
    var array5 = array3+array4

    Swift中提供了许多访问和修改数组的方法,示例代码如下:

    //获取数组中元素个数
    array5.count    //6
    //判断数组是否为空
    array5.isEmpty  //false
    //判断数组是否包含某个元素,有则返回所包含的元素个数
    array5.index(of: 1);    //nil
    array5.index(of: 2.5);  //3
    
    //通过下标访问数组中的元素
    array5[1]   //0
    
    //通过下标修改数组元素
    array5[1]=2 //2
    //修改数据中的一组数据
    array5[0...3] = [1,1]   //[1, 1, 2.5, 2.5]
    
    //替换数据中的一组数据,作用与修改一样
    array5.replaceSubrange(Range(1..<2), with: [66,77,88,99]) //[1, 66, 77, 88, 99, 2.5, 2.5]
    
    //向数组中某个位置插入一个数据
    array5.insert(3, at: 1) //[1, 3, 66, 77, 88, 99, 2.5, 2.5]
    
    //移除数组某个角标处的元素
    array5.remove(at: 1)    //[1, 66, 77, 88, 99, 2.5, 2.5]
    
    //移除数组的最后一个元素
    array5.removeLast() //[1, 66, 77, 88, 99, 2.5]
    
    //移除数组第一个元素
    array5.removeFirst()    //[66, 77, 88, 99, 2.5]
    
    //遍历整个数组
    for item in array5 {
        print(item)
    }
    //遍历数组枚举
    for (index,item) in array5.enumerated() {
        print(index,item)
    }
    //移除数组所有元素
    array5.removeAll()  //[]

    三、Set类型

    Set类型集合不关注元素的顺序,但是其可以保证其中元素的唯一性。和Array类型一样,Set类型来声明时也需要确定其内元素的类型,示例如下:

    var sets1 = ["qwe","asd","zxc"] //["qwe", "asd", "zxc"]
    type(of:sets1)  //Array<String>.Type
    //Set类型不能从数组字面量中被单独推断出来,因此Set类型必须显式声明,但是可以不声明具体类型,具体类型可以自检
    var sets2: Set = ["qwe","asd","zxc"]    //{"zxc", "qwe", "asd"}
    type(of:sets2)  //Set<String>.Type

    下面示例代码演示对集合进行操作:

    var set1:Set<Character> = ["a","b","c","d"]
    //向集合中插入元素
    set1.insert("z")    //(.0 true, .1 "z") 返回值中true表示成员不重复,插入成功
    set1    //{"b", "a", "d", "c", "z"}
    set1.insert("z")    //(.0 false, .1 "z") 返回值中false表示成员重复,插入失败
    
    //获取集合中元素个数
    set1.count  //5
    //判断集合是否为空
    set1.isEmpty    //false
    //判断集合中是否包含某个元素
    set1.contains("e")  //false
    //将集合中的某个元素移除
    set1.remove("a")    //{"b", "d", "c", "z"}
    
    //遍历集合
    for item in set1 {
        print(item)
    }
    //进行从小到大的排序遍历
    for item in set1.sorted() {
        print(item)
    }
    
    //移除集合中的所有元素
    set1.removeAll()    //Set([])

    Set也支持进行一些集合的数学运算,例如交集,并集,补集等,下面一张图演示了Set进行集合运算的一些特性:
    这里写图片描述
    - intersection(_:) 交集,根据两个集合中都包含的值 创建 的一个新的集合。
    - symmetricDifference(_:) —> 交集的补集,根据在一个集合中但不在两个集合中的值 创建 一个新的集合。
    - union(_:) —> 并集,根据两个集合的值 创建 一个新的集合。
    - subtracting(_:) —> 第二个集合的补集,在第一个集合中 根据不在第二个集合中的值 创建 一个新的集合。
    - subtract(_:) —> 第二个集合的补集,并且从第一个集合中移除交集的元素。没有返回值!

    示例代码如下:

    let sets10: Set = [1, 2, 3, 4, 5, 6]
    var sets11: Set = [4, 5, 6, 7, 8]
    
    
    //交集
    let set01 = sets11.intersection(sets10) //返回{4, 5, 6},sets11和sets10值不变
    sets11
    sets10
    
    //交集的补集
    let set02 = sets11.symmetricDifference(sets10)  //返回{1, 2, 3, 7, 8},sets11和sets10值不变
    
    //并集
    let set03 = sets11.union(sets10)   //返回{1, 2, 3, 4, 5, 6, 7, 8},sets11和sets10值不变
    
    //第二个集合的补集
    let set04 = sets11.subtracting(sets10)  //返回[7, 8],sets11和sets10值不变
    sets11
    
    //第二个集合的补集,并且从第一个集合中移除交集的元素。没有返回值
    sets11.subtract(sets10)  // sets11的值变为[7, 8] 和 sets10值不变
    //let set05:Set<Int> = sets11.subtract(sets13)  //错误,subtract没有返回值!
    let set05 = sets11  //[7, 8]
    • “相等”运算符 ( == ) —> 判断两个集合是否相等;
    • isSubset(of:) —> 判断第一个集合是否是第二个集合的子集;
    • isSuperset(of:) —> 判断第一个集合是否是第二个集合的超集,即第一个集合是否包含第二个集合的所有值;
    • isStrictSubset(of:) —> 判断是否是某个集合的真子集,即这个集合是某一个集合的子集,但它们并不相等;
    • isStrictSuperset(of:) —> 判断是否是某个集合的真超集,即这个集合是某一个集合的超集,但它们并不相等;
    • isDisjoint(with:) —> 判断两个集合是否没有相同的值。没有相同的值则返回true,有则false。

    下面代码显示了与子集相关的运算:

    sets11 = [4, 5, 6, 7, 8]
    let sets12: Set = [4, 6, 8]
    let sets13: Set = [4, 5, 6, 7, 8]
    let sets14: Set = [1, 3, 5, 7, 9]
    
    //判断是否相等
    sets11 == sets12    //false
    sets11 == sets13    //true
    
    //判断第一个集合是否是第二个集合的子集
    sets11.isSubset(of: sets12) // false
    sets12.isSubset(of: sets11) // true
    
    //判断第一个集合是否是第二个集合的超集
    sets11.isSuperset(of: sets12)   // true
    sets12.isSuperset(of: sets11)   // false
    
    //判断是否是某个集合的真子集,
    sets12.isStrictSubset(of: sets11)   //true
    sets13.isStrictSubset(of: sets11)   //false
    
    //判断是否是某个集合的真超集
    sets11.isStrictSuperset(of: sets12) //true
    sets11.isStrictSuperset(of: sets13) //false
    
    //判断两个集合是否没有相同的值,没有则返回true
    sets11.isDisjoint(with: sets12)// false
    sets12.isDisjoint(with: sets14)// true

    四、Dictionary类型

    Swift中的Dictionary在声明时必须明确键的类型和值的类型,示例如下:

    var dic:Dictionary<Int,String>
    var dic1:[Int:String] = [1:"one",2:"Two"]

    访问与操作Dictionary的方法,代码示例如下:

    var dic2:[Int:String] = [1:"One",2:"Two",3:"Three",4:"Four"]
    //获取字典键值对个数
    dic2.count  //4
    //判断字典是否为空
    dic2.isEmpty    //false
    //通过键获取值
    dic2[1] //"One"
    
    //添加或修改: 字典变量[键] = 值
    //通过键修改值
    dic2[1] = "First"   //[2: "Two", 3: "Three", 1: "First", 4: "Four"]
    //添加键值
    dic2[0] = "Zero"    //[0: "Zero", 2: "Two", 3: "Three", 1: "First", 4: "Four"]
    
    
    //updateValue 方法将更新一个键值 如果此键存在 则更新键值 并且将旧的键值返回 如果此键不存在 则添加键值 返回nil 其返回的为一个Optional类型值 可以使用if let进行处理
    dic2.updateValue("9", forKey: 1)    //"First"
    //使用if let 处理updateValue的返回值
    if let oldValue = dic2.updateValue("One", forKey: 1) {
        print("Old Value is \(oldValue)")   //"Old Value is 9\n"
    }
    //通过键值获取的数据也将是有个Optional类型的值 也可以使用if let
    if let value = dic2[1] {
        print("The Value is \(value)")  //"The Value is One\n"
    }
    
    //如果有此键,则移除某个键值对
    dic2    //[0: "Zero", 2: "Two", 3: "Three", 1: "One", 4: "Four"]
    dic2[9]=nil //没有此键,忽略
    dic2[0]=nil //[2: "Two", 3: "Three", 1: "One", 4: "Four"]
    //如果有此键,则返回其值,并移除键值对,没有则返回nil
    dic2.removeValue(forKey: 0) //没有此键,忽略
    dic2.removeValue(forKey: 1) //返回“One”,dic2变为[2: "Two", 3: "Three", 4: "Four"]
    
    
    //对字典进行遍历
    for (key,value) in dic2 {
        print(key,value)
    }
    //遍历所有键
    for key in dic2.keys {
        print(key)
    }
    //遍历所有值
    for value in dic2.values {
        print(value)
    }
    //进行从小到大的排序遍历
    for key in dic2.keys.sorted() {
        print(key)
    }
    

    原文https://my.oschina.net/u/2340880/blog/673359,仅针对swift3做少量更改。

    展开全文
  • 这章节介绍集合的另一种类型Set,...与Array不同,Set没有类似的简写格式。 创建并且初始化一个空的Set: var letters = SetCharacter>() print("letters is of type Set with \(letters.count) items.") /
  • String(字符串)的遍历方法1: var str = "china" for item in str.characters{ print(item) } 方法2: var str = "china" for item in str.characters.indices{ print(str[item]) } ...var str = "china" ...
  • swift3 本地存储array, UserDefaults
  • 以前使用过OC版本的CoreData应该很好理解Swift方式,所以这里简单的展示一下,增删改查的方法使用,同时给大家说一下创建步骤,方便大家的使用,转载请注明出处,谢谢~步骤一:创建一个Swift的新项目,记得勾选对应...
  • swift数组只有一个 var dataSource = ["A","B","C","D"] dataSource.remove(at: i) 如果我要实现类似OC数组的removeObject方法咋办呢? 网上有人解答的思路是这样的:首先,找到数组中该元素所在的位置,然后使用...
  • Swift提供了三个主要的集合类型来存储值的集合:ArraySet,Dictionary。Array是有序的值的集合,Set是无序的不重复的值的集合,Dictionary是无序的键值对集合。 在SwiftArraySet和Dictionary存储的键值的...
  • Swift的get和set方法

    2016-07-10 17:34:08
    在设置属性值时:Swift会自动给我们创建一个名为newValue的常量并且可以用于set{}中。 计算属性本身不是一个值,但是它提供get和set来间接地使用和设置存储属性的值 例子: @IBOutlet weak var ...
  • iOS - Swift Set 集合

    2019-01-14 02:40:02
    Set:集合 public struct Set&lt;Element : Hashable&gt; : Hashable, CollectionType, ArrayLiteralConvertible public class NSSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, ...
  • var array:[String] = [] let result = Array(Set(array))
  • Swift提供了三种主集合类型,称为数组,集合和字典,用于存储值的集合。 数组是值的有序集合。集合是唯一值的无序集合。 字典是键-值关联的无序集合。   一、数组 数组(Array)在有序列表中存储相同类型的值。相同的...
  • Swift语言提供ArraySet和Dictionary三种基本的集合类型用来存储集合数据。数组是有序的数据集;集合是无序无重复的数据集;而字典是无序的键值对数组集。 SwiftArraySet和Dictionary类型被实现为泛型集合。...
  • iOS - Swift Array 数组

    2019-05-15 01:46:19
    前言 public struct Array<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSe...
  • 目录版本简介ArraySetDictionary 版本 Xcode 11.0 Swift 5.1 简介 1. 简介 Swift三种基本集合类型: 数组(Array): 使用有序列表存储同一类型的多个值, 相同的值可以出现在不同位置中. 集合(Set): 存储相同类型并且...
  • ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★➤微信公众号:山青咏芝(shanqingyongzhi)➤博客园地址:山青咏芝(https://www.cnblogs.com/strengthen/)➤GitHub地址:...
1 2 3 4 5 ... 20
收藏数 5,294
精华内容 2,117
热门标签