Swift入门基础2——集合和枚举

数组

创建一个数组，可变的空数组，打印结果为[]

        var arr1 = [String]()
        print(arr1)

以字面量初始化一个数组：

        var arr1: [String] = ["wang66", "wang77", "wang88"]
        print(arr1)

因为Swift有类型检测，所以不用申明数组类型也完全可以，它会根据所赋的字面值自己推断未String类型

        var arr1 = ["wang66", "wang77", "wang88"]
        print(arr1)

给数组追加新的元素：

        var arr1: [String] = ["wang66", "wang77", "wang88"]
        arr1.append("wang99")
        print(arr1)

给数组追加新的数组:

        var arr1: [String] = ["wang66", "wang77", "wang88"]
        arr1 += ["wang99", "wang00"]
        print(arr1)

将俩数组拼接。在Swift中字符串和集合拼接都用+号就行

        var arr1: [String] = ["wang66", "wang77", "wang88"]
        var arr2 = ["wang99", "wang00"]
        var resultArr = arr1 + arr2
        print(res ultArr)

对数组进行删除操作。下面几个删除方法均有返回值，返回被删除的数组元素。通常情况下你不用管返回值。

        var arr1: [String] = ["wang66", "wang77", "wang88"]
        arr1.removeLast()
        arr1.removeFirst()
        let deletedElement = arr1.remove(at: 0)
        print(deletedElement)
        print(arr1)

修改、更新数组元素。你不仅可以通过下标索引修改一个元素，也可以批量修改。

        var arr1: [String] = ["wang66", "wang77", "wang88"]
        arr1[0] = "Jobs"
        arr1[1...2] = ["Yaren", "Tom"] // 根据下标区间，批量修改
        print(arr1)

读取数组。

        let str0 = resultArr[0]
        print(str0)

        let strFirst = resultArr.first
        if let tempStr = strFirst{
            print(tempStr)
        }
        print(strFirst!)
        
        let strLast = resultArr.last
        print(strLast!)

数组中插入元素

        var arr1: [String] = ["wang66", "wang77", "wang88"]
        arr1.insert("wang00", at: 0)
        print(arr1)

遍历数组。当需要数组索引时，可以用enumerated()遍历得到一个个元组，index即为索引，value即为元素的值。

        // 遍历数组
        for item in resultArr {
            print(item)
        }
        for (index, value) in resultArr.enumerated() {
            print("item=\(index), value=\(value)")
        }

---

字典

字典的用法和数组很相似。

创建一个字典。一个key和value均为String类型的字典，随即设置字符串"wang1"为键"name"的值

        var dict1 = [String:String]()
        dict1["name"] = "wang1"
        print(dict1)

以字面量初始化一个字典。键值均为String类型，且已有两个键name和age。

        var dict2: [String:String] = ["name":"wang1", "age":"23"]
        print(dict2)

与数组类似的，它也完全可以不必申明键值类型，Swift会自己检测

        var dict3 = ["name":"wang1"]
        print(dict3)

修改、更新键值。也提供了updateValue(value: forkey:)方法，它有返回值，代表被修改的键的原始值。一般可忽略该返回值。

        var dict = ["name":"wang66", "age":"24"]
        dict["age"] = "18"
        let result = dict.updateValue("wang666", forKey: "name")
        print(result!)
        print(dict)

删除字典元素，删除某键对应的数据。

        var dict = ["name":"wang66", "age":"24"]
        dict.removeValue(forKey: "age")
        print(dict)

遍历字典。遍历字典时是一个个的元组。

        // 遍历
        for (dictKey, dictValue) in dict1 {
            print("\(dictKey)=\(dictValue)")
        }
        
        // 遍历所有key
        for key in dict1.keys {
            print("key=\(key)")
        }
        
        // 遍历所有values
        for value in dict2.values {
            print("value=\(value)")
        }

---

枚举

在OC中可以把枚举理解为取了个别名的整型数。但是Swift的枚举却发生了很大变化，它可以是任意类型。应该这么说，定义了一个枚举，就是定义了一个类型，它里面的成员的类型就是该枚举，它有点类似类和结构体的感觉。 比如下面定义了一个PositionType枚举，对于它的成员north,south...来说，它们的类型就是PositionType。

enum PositionType {
    case north
    case south
    case east
    case west
}

使用时直接用点语法就可以了。当通过点语法将枚举值赋给direction时，Swift便会推断出其类型，所以再后续操作direction时，甚至可以省略枚举名了，直接用点语法点出它的成员来。

        var direction = PositionType.north
        direction = .east
        print(direction)
        // log:east

Swift中可以给枚举的成员设置“原始值”，所有成员的原始值的类型必须相同。下面这个叫BallType的枚举，它的成员原始值都是String类型的。

enum BallType: String {
    case basketball = "BB"
    case football = "FB"
    case golfball = "GB"
}

现在给枚举的成员已然设置了“原始值”，那我们怎么获取“原始值”呢？——通过成员的rawValue方法。

        let rawValue = BallType.basketball.rawValue
        print(rawValue)

** 枚举的隐式赋值：**虽说Swift中的枚举成员不像OC那样，默认第一个成员值为0，然后依次递增。Swift的枚举成员默认是没值的，更不用说值递增了。但是，若你手动的给第一个成员设置一个值，那此时，它后面的成员便会递增。

定义一个分数等级的枚举。将第一个成员D手动赋值为1。

// 分数等级
enum ScoreLevel: Int {
    case D = 1
    case C
    case B
    case A
}

获取成员B的值，打印结果可以看到B的值为3。

        let score = ScoreLevel.B.rawValue
        print(score)
        // log:3