【基础篇】4 数据结构：元组、数组、字典、集合

除了常使用的变量、常量以外，和其它编辑语言一样swift提供了常用的数据结构，在用上也大同小异。编程中的一个重要任务就是把逻辑相关的一组值放在一起。

一、元组

前面已使用了多次元组，元组可以将多个值的有限的组合起来，不同的值被组合为单个复合值，组合的结果是一个元素的有序列表。

let myVar = ("字符串",200,true)//元组可以放入不同的值
var str:String,num:Int,isTrue:Bool //定义接收元组的变量
(str,num,isTrue) = myVar //将元组分别存入变量中
print(str)//字符串
print(num)//200
print(isTrue)//true

//下面演示直接访问元组
print(myVar.0)//字符串
print(myVar.1)//200
print(myVar.2)//true

很多时候元组都是用于接收函数返回的多个值，也会用在数据库查询返回等。

下面演示给元组索引命名：

let siteInfo = (name:"网络人",url:"55mx.com",age:10)//元组索引x命名
print(siteInfo.name + "（" + siteInfo.url + "）已经运行" + String(siteInfo.age) + "年了")
//网络人（55mx.com）已经运行10年了
var (name,url,_) = siteInfo//忽略age,let也适用哦
print(name)//网络人

二、数组

Swift 数组使用有序列表存储同一类型的多个值。和GO语言差不多相同的值可以多次出现在一个数组的不同位置中。

 1、数组的定义与访问：

var num:[Int] = [10, 20, 30]//定义数组指定类型
print(num[0])//访问第1个数组里的数据：10
//快速创建推导出类型的数组
var names =[
    "张三",
    "李四",
    "王五",
    "55mx.com"
]
var num2:Array//与var num2:[Int]一样

数组的索引从 0 开始，即索引 0 对应第一个元素，与其它编程无差异。

2、批量初值化数组

var nums = [Int](repeating: 0, count: 10)//批量初始化值为0，初始10个元素
for (i, item) in nums.enumerated() {
    print("第"+ String(i) +"个元素的值:" + String(item))
}
//直到nums[9]输出的值都是0

3、遍历数组

上面看到遍历数组使用for...in的方式，如果取到索引我们需要使用到enumerated方法。只要值则不需要：

for item in nums{
   print(item)
}

4、修改数组

可以使用 append() 方法或者赋值运算符 += 在数组末尾添加元素，如下所示，我们初始化一个数组，并向其添加元素：

var Names = [String]()//初始化一个空数组
Names.append("张三")
Names.append("李四")
Names += "王五" //和上面一样在尾部追加

Names[2] = "王五五"//通过索引值修改最后一个数组元素
print(Names.count)//打印数组值的个数：3
print(Names[0...2])//打印数组索引0~2的值

Names[1...2] = ["李四四","王三五"]//可以通过下标语法来一次性改变一定范围内的值，即便你要改变的元素个数和你提供的元素个数不一致也可以。

5、数组合并

可以使用加法操作符（+）来合并两种已存在的相同类型数组。新数组的数据类型会从两个数组的数据类型中推断出来：

var intA：[Int] = [10,20,30]
var intB = [Int](repeating: 1, count:3)//初始为1，重复3次

var intC = intA + intB //将A和B合并后交给C

for item in intsC {
    print(item)
}
/*
打印结果：
10
20
30
1
1
1
*/

6、数组自带的属性与方法：

a.count 属性 计算数组元素个数（上面代码里有使用）。

b.isEmpty 属性 来判断数组是否为空，返回布尔值。

c.append(_:)方法 追加一个数组元素在尾部。也可以使用 +=代替（上面有使用到）。

d.remove(at:)方法 删除一个数组元素，at:后面紧跟索引值

e.insert(_:,at:)方法 把新元素插入到数组索引at:的指定位置。

f.==检查数组是否相等，数组内容一样，索引位置不一样返回false。

g.removeLast() 删除数组最后一个元素。

h.removeFirst() 删除数组第一个元素。

三、字典

字典是一个key->value的容器类型，在GO语言里可以视为map类型。在swift里常常用于json转换。

Dictionary中的键是唯一的，每个键都唯一映射到对应的值。Swift 字典用来存储无序的相同类型数据的集合，Swift 字典会强制检测元素的类型，如果类型不同则会报错。

1、创建字典，语法为 var myDict =  [KeyType: ValueType]()或者 var myDict:Dictionary

var myDict = [String:Int]()//初始一个索引为String，值为Int的字典
var myDict1: = [:]//和上面一样
//下面带关键字Dictionary
var myDict2 = Dictionary() //和上面一样
var myDict3:Dictionary = [:]//和上面一样

这4种方法得到的结果一样，按自己喜欢的方式创建字典即可。

2、填充并访问字典

上面代码初始化了一个字典，现在我们使用下面的代码对字典进行填充操作：

var myDict = ["one":1,"two":2,"three":3] //使用推导定义字典
print(myDict["one"])//直接打印会报错：Optional(1) warning: expression implicitly coerced from 'Int?' to 'Any'
print(myDict["one"]!)//加上"!"符号强制访问

 字典取值需要通过key关联取到value，字典里的value值是一个可为空的Optional类型，上面为Int?类型，因为Dictionary需要有一种方法告诉你请求的值不存在。如果我们知道值确实存在可以使用"!"读值。

3、修改和更新值

var myDict = ["one":1,"two":2,"three":3] //使用推导定义字典
myDict["one"] = 5 //把myDict["one"]的值改为5
print(myDict["one"]!)//打印：5
myDict.updateValue(6,forKey:"one")//把myDict["one"]的值改为6
print(myDict["one"]!)//打印：6

updateValue(_, forKey: ) 通过Key更新一个元素的值，与=不一样的是updateValue会返回被修改的旧值。

4、增加与删除值

//接上面代码
myDict["four"] = 4//增加一个four元素
print(myDict)//["four": 4, "two": 2, "three": 3, "one": 1]
myDict.removeValue(forKey:"four")//删除Key = four的元素
print(myDict)//["one": 1, "two": 2, "three": 3]

myDict["one"] = nil//通过赋值为nil来删除一个元素

removeValue(forKey:)方法接受一个键作为参数删除一个字典元素，如果健存在并且成功删除，这个方法还会返回与其关联的值。如果元素不存在返回nil，所以返回值是一个Optional可空类型。

5、遍历字典

使用for...in循环可以遍历字典。

var myDict = ["one":1,"two":2,"three":3]
for (key,value) in myDict{
    print("Key = " + key + "，value = " + String(value))
}
/*
Key = two，value = 2
Key = three，value = 3
Key = one，value = 1
*/

健名与值分开访问：

var myDict = ["one":1,"two":2,"three":3]
//只要健名不要值
for key in myDict.keys{
    print("Key = " + key)
}
/*
等同于：for (key,_) in myDict
Key = one
Key = two
Key = three
*/
//只要值，不要键名
for value in myDict.values{
    print("value = " + String(value))
}
/*
等同于：for (_,value) in myDict
value = 1
value = 2
value = 3
*/

 6、字典转数组

var myDict = ["one":1,"two":2,"three":3]
let Keys = [String](myDict.keys) //将myDict的key转为数组
let Values = [Int](myDict.values)//将myDict的value转为数组
print(Keys) //["one", "three", "two"]
print(Values) //[2, 1, 3]

还可以使用下标语法从字典中检索特定键的值。

if let five = myDrct["five"] {
    print("在 myDrct 里找到了元素five")
} else {
    print("five这个元素在myDrct中不存在")
}

7、字典的方法与属性

a.count 属性 返回字典的元素个数

b.isEmpty 属性 返回字典是否为空

c.updateValue(_,forKey:) 更新key的值后返回旧值。返回类型为String?或“ optional String”的值

d.removeValue(forKey: )删除一个元素

四、集合

swift提供(set)容器类型,Set不是很常见，纯粹只是因为约定成俗而提供的。集合是一组互不相同的实例的无序组合。这个定义将其与数组区别开来（数组是有序的并可以重复值）。

 通过上图，我们可以大概知道set集合容量的原理。

 1、定义集合

let Digits1: Set = [1, 3, 5, 7, 9]//定义一组奇数集合Digits1
let Digits2: Set = [0, 2, 4, 6, 8]//定义一组偶数集合Digits2
let Digits: Set = [2, 3, 6, 7]//定义一组整数集合Digits
//下面是集合的方法
Digits1.union(Digits2).sorted()// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Digits1.intersection(Digits2).sorted() // []
Digits1.subtracting(Digits).sorted() //[1, 9]
Digits1.symmetricDifference(Digits).sorted()// [1, 2, 9]

a.union(_:)  方法创建一个包含两个集合中所有值的新集合(并集)。

b.intersection(_:) 方法创建一个Digits1与Digits2都有的元素集合(交集)

c.subtracting(_:) 方法与上面的相反，创建一个值不在指定集合中的新集合（差集）。

d.symmetricDifference(_:) 方法 其中的值在其中一个集中，但不能同时在两个集中。

2、集合插入与判断

我们可以使用insert(_:)方法给集合插入新的值。

var num = Set()//初始化一个集合
num.insert(100)
num.insert(200)
num.insert(300)
print(num)//[300, 100, 200]

//下面的代码与上面实现的功能一样
var num2 = Set([100,200,300,100])//初始化集合并插入元素
print(num2)//[300, 200, 100]

//num与num2的集合一样
if num==num2{
print("num与num2的集合一样")
}

3、集合里的其它方法：

a.使用“等于”运算符（==）确定两组是否包含所有相同的值(上面有用过)。

b.isSubset(of:)方法确定指定集合中是否包含集合的所有值（num.isSubset(of: num2)）。

c.isSuperset(of:)方法确定集合是否包含指定集合中的所有值（num.isSuperset(of: num2)）。

d.isStrictSubset(of:)或isStrictSuperset(of:)方法来确定集合是子集还是超集，但不等于指定的集。

e.isDisjoint(with:)方法确定两个集合是否没有共同的值。

f.contains(_:)方法来查看其内部是否有某个元素 num.contains(100)返回true。

 五、三种容器的区别

容器类型	有序	唯一	存储
数组Array	是	否	元素
字典Dictionary	否	键	键值对
集合Set	否	元素	元素

 

除非注明，网络人的文章均为原创，转载请以链接形式标明本文地址：https://www.55mx.com/post/102