swift-集合类型Swift 语言提供数组（Array）、集合（Set）和字典（Dictionary）三种基本的*集合

Swift 语言提供数组（Array）、集合（Set）和字典（Dictionary）三种基本的集合类型用来存储集合数据。数组是有序数据的集。集合是无序无重复数据的集。字典是无序的键值对的集。swift官方开发文档中的这张图十分清晰的描述了3种集合类型的区别。

集合的可变性

在上一篇文章，介绍字符串的时候，就说过字符串的可变性，这里集合的可变性和字符串类似。创建一个集合并把它分配给一个变量，这个结合就是可变的。相反，分配成一个常量，就是不可变的。

数组

Swift 的 Array 类型被桥接到 Foundation 中的 NSArray 类。

定义有初始值的数组

var a = [1,2,3,4]

print(a)

var b:[String] = ["hello", "hai"]

var c:Array<Double> = [1.0,3.4,5.9]
print(c)

数组a，由于 Swift 的类型推断机制，当用字面量构造拥有相同类型值数组的时候，不一定需要显示的指定类型，如果数组在声明时设置了初始值，则编译器会根据赋值类型自动推断出数组的类型。

定义空数组

var array:Array<Int> = []
var array1 = [Int]()
var array2: [Int] = []

其他定义方式

var array3 = Array(repeating: -1, count: 3)//初始值为-1 长度为3

let array4 = [4,5,6]//不能修改

数组操作

可以使用数组的只读属性 count 来获取数组中的数据项数量：

var shoppingList = ["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 不是空的）

增删改查

//合并
array = array + [2,6]
print(array)

//追加元素
array.append(4)

//用下标来改变某个有效索引值对应的数据值：
array[0] = 0

array.insert(999, at: 0)

array.remove(at: 0)

是否包含某个元素

array.contains(2)

替换

array.replaceSubrange((1..<3), with:[3,4])
print(array)

排序

var sortArr = ["a","b","c","d","e","f"]

sortArr.sort { (s1, s2) -> Bool in
    if s1 > s2 {
        return true
    } else {
        return false
    }
}

print(sortArr)

过滤

var filterArr = sortArr.filter { (item) -> Bool in
    if item != "d" {
        return true
    } else {
        return false
    }
}

print(filterArr)

比较

if array1 == array3 {
    print("equal")
}

遍历

for item in array3 {
    print(item)
}

for item in array1[1...2] {
    print(item)
}

for index in 0..<array.count {
    print(array[index])
}

//反向
for index in (0..<array.count).reversed() {
    print(array[index])
}
//遍历数组中所有值
for index in array[0...] {
    print(array[index])
}

set集合

集合是同类型数据的集合：无序，无索引，同值元素只保留一个。

定义

var a:Set = [1,3,5,6,7,9]
print(a)

var b:Set<String> = ["a","c","f","r","o"]
print(b)

var c:Set<Int> = []
print(a.count)//长度

操作增删改查

由于set并不关注其中元素的顺序，因此通过下标的方式来取值对set并无意义。需要注意，set的下标操作是不可逆的操作，只能向后移动，不能向前移动。

a.update(with: 1)
a.insert(99)

a.contains(9)//返回bool

var removeIndex = a.index(after: a.startIndex)
a.remove(at: removeIndex)

a.remove(3)

合并等其他操作

//合并两个set 返回新的set
var new_set = a.union(c)

 //两个set中相同数据
var new_set1 = a.intersection(c)

//两个set中不同数据
var new_set2 = a.symmetricDifference(c)


//返回前面set与后面set中不同的数据
var new_set3 = a.subtracting(c)

比较

//相等
if a == c {
    print("equal")
}

var scores1:Set = [11, 4, 3, 0, 5,8]
var scores2:Set = [4, 3, 5]
let b3 = scores1.isSubset(of: scores2)              // 1是否为2的子集 b3 is false
let b4 = scores1.isSuperset(of: scores2)            // 1是否为2的父集 b4 is true
let b5 = scores1.isStrictSubset(of: scores2)        // 1是否为2的子集并不相等 b5 is false
let b6 = scores1.isStrictSuperset(of: scores2)      // 1是否为2的父集并不相等 b6 is true
let b7 = scores1.isDisjoint(with: scores2)          // 是否没有交集 b7 is false

过滤

var filter_set = a.filter { (item) -> Bool in
    if item != 6 {
        return true
    } else {
        return false
    }
}

遍历

for item in a {
    print(item)//每次打印顺序都不一样
}

Dictionary

定义

var a:Dictionary<String,String> = ["a":"A","b":"B","c":"C"]
print(a)

var b:[Int:String] = [1:"a",2:"b",3:"c"]
print(b)

var c = ["hello":"hai"]

var d = [Int:String]()

print(a["a"] ?? "unknow")

操作

a["a"] = "AA"
a.updateValue("aaa", forKey: "a")
print(a)
//没有key  就会把key-value 添加到dictionary中
a.updateValue("d", forKey: "d")

a.removeValue(forKey: "a")
//通过键来获取字典中的值时，也会返回一个optional类型的值，若键不存在则是nil，所以可以使用if-let来保证程序安全性
if let value = a["b"] {
    print(value)
}

过滤

var new_dic = a.filter { (key,value) -> Bool in
    if key == "a" {
        return false
    } else {
        return true
    }
}

遍历

//使用元组可以同时把key value遍历出来
for (key,value) in a {
    print(key,value)
}

swift-集合类型