Swift--字符、字符串与集合类型

系列文章目录

第一章：量值与基本数据类型
第二章：字符、字符串与集合类型

---

---

Swift是一种弱化指针的语言，它提供了String类型和Character类型来描述字符串与字符

//构造一个字符串
var str = "hello"
//构造一个空字符串
var str2 = ""

1
2
3
4
5

Sring类型提供了很多重载的构造方法，开发者可以传入不同类型的参数来构造需要的字符串。实际上，Swift语言中的String类型提供的构造方式十分宽泛，甚至可以将其他类型通过构造方法转换为字符串

//直接赋值
var str:String = "hello"
//直接赋值空字符串
str = ""
//通过构造方法进行str变量的构造
//构造空字符串“”
str = String()
//通过字符串构造“hello”
str = String("hello")
//通过整形数据构造“666”
str = String(666)
//通过浮点型数据构造“6.66”
str = String(6.66)
//通过字符构造“a”
str = String("a")
//通过Bool值构造“false”
str = String(false)
//通过元租构造“（1， 1.0， true）“
str = String(describing: (1, 1.0, true))
//通过列表构造“【1， 2， 3】”
str = String(describing: [1, 2, 3])
//通过格式化字符串构造“myhuacheng”
str = String(format: "my:%@", "huacheng")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

//通过类型来构造字符串Int
str = String(describing:  Int.self)
1
2

字符串组合

Swift中的String类型对“+”运算符进行了重载实现，即开发者可以直接使用“+”符号将多个字符串组合拼接为新的字符串
“()”结构可以将其他数据类型转换为字符串类型并且插入字符串数据的相应位置，也可以进行简单的运算逻辑后将结果插入原字符串中

var d = "Hello \(123)"
var d2 = "hello \(1 + 2)"
var d3 = "hello \("world")"
1
2
3
4

Swift语言中使用Character来描述字符类型，Character类型和String类型都占16字节的内存空间

//16个字节 获取String类型占用的内存空间
MemoryLayout<String>.size
//character用来描述一个字符， 我们将一组字符组合成为一个数组，用于构造字符串


//创建一个字符
var e: Character = "a"
//创建字符数组
var e2: [Character] = ["H", "E", "L", "L", "O"]
//通过字符数组构造字符串“HELLO”
var e3 = String(e2)
1
2
3
4
5
6
7
8
9
10
11
12

使用for-in遍历可以将字符串中的字符拆解出来，这种方法有时十分好用，for-in遍历是Swift语言中一种重要的代码流程结构

//通过构造方法来创建字符型变量
var e4 = Character("a")
//进行for-in遍历
let name = "china"
for character in name {
    print(character)
}
1
2
3
4
5
6
7

for-in结构是一种重要的循环结构，上面的示例代码中，in关键字后面需要为一种可迭代的类型，in关键字前面是每次循环从迭代器中取出的元素，其类型会由Xcode编译器自动推断出来

String类型的实例通过使用isEmpty方法来判断字符串的值是否为空字符串

var obj1 = ""
if obj1.isEmpty {
    print("yes")
}
1
2
3
4
5

还有一种方式也可以用来判断一个字符串变量是否为空字符串，即当字符串变量中的字符数为0时，也可以认定此字符串为空字符串，即通过字符串的count属性判断其中的字符个数是否为0

String类型的实例除了可以使用“+”直接拼接外，还可以使用比较运算符

var com1 = "30a"
var com2 = "31a"
if com1 == com2
{
    print("yes")
}
if com1 < com2 {
    print("com1 < com2")
}

1
2
3
4
5
6
7
8
9
10

在比较两个字符串的大小时，会逐个对字符的大小进行比较，直至遇到不相等的字符为止。上面的示例代码可以这样理解：先比较com1字符串与com2字符串的第1个字符，若相等，再比较第2个字符，以此类推。由于com2的第4个字符（2）大于com1的第4个字符（1），因此com2字符串大于com1字符串。

可以通过下标的方式来访问字符串中的每一个字符，获取字符串起始下标与结束下标的方法如下

var string = "hello-world"
//起始下标
var startIndex = string.startIndex
//终止下标
var endIndex = string.endIndex
1
2
3
4
5
6
7

startIndex和endIndex是Index类型不是整数类型，他们不能直接进行加减操作

//获取某个下表后一个下表对应的字符 char = “e”
var char = string[string.index(after:  startIndex)]
//获取某个下标前一个下标对应的字符 char2 = “t”
var char2 = string[string.index(before: string.endIndex)]
1
2
3
4

上面的代码中，index(after:)方法用来获取当前下标的后一位下标，index(before:)方法用来获取当前下标的前一位下标。也可以通过传入下标范围的方式来截取字符串中的某个子串

var subString = string[startIndex...string.index(startIndex, offsetBy: 4)]
var subString2 = string[string.index(endIndex, offsetBy: -5)..<endIndex]
1
2
3

“…”为范围运算符，在后面的章节中会详细介绍，offsetBy参数传入的是下标移动的位数，若向其中传入正数，则下标向后移动相应位数，若向其中传入负数，下标向前移动相应位数。使用这种方式来截取字符串十分方便。String类型中还封装了一些方法，可以帮助开发者便捷地对字符串进行追加、插入、替换、删除等操作

三种集合

数组

数组中能够存放的元素并非只是数字，它可以存放任意类型的数据，但是所有数据的类型必须统一

//Int类型数组
var array1:[Int]
var array2:Array<Int>

//创建空数组
array1 = []
array2 = Array()
//创建整数型数组
array1 = [1, 2, 3]
//通过一组元素创建数组
array2 = Array(arrayLiteral: 1, 2 ,3)
1
2
3
4
5
6
7
8
9
10
11

空数组的含义并非是变量为nil，而是数组中的元素为空，Swift中只有Optional类型的变量可以为nil
数组采用结构体来实现，对于大量重复元素的数组，开发者可以直接使用快捷方法来创建

//创建大量有相同元素的数组，
//创建10个String类型元素的数组，并且每个元素都是字符串“Hello”
var array3 = [String](repeating: "Hello", count: 10)
//创建有10个Int类型数据的数组，每个元素都是1
var array4 = Array(repeating: 1, count: 10)
1
2
3
4
5
6

数组在声明时必须要明确其类型，但是开发者并不一定需要显式地指定类型，如果数组在声明时也设置了初始值，则编译器会根据赋值类型自动推断出数组的类型

数组数组中对加法运算符也进行了重载，开发者可以使用“+”进行两个数组的相加，相加的结果即将第2个数组中的元素拼接到第1个数组后面。需要注意，相加的数组类型必须相同

var array = [1, 2, 3, 4, 5, 6, 7, 8, 9]
//获取数组中元素个数 9
print(array.count)
if array.isEmpty {
    print("array empty")
}
//通过下标获取数组中的元素 1
var a = array[0]
print("通过下标获取数组中的元素1 ", array)
//获取区间元素组成的新数数组[1, 2, 3, 4]
var sunArray = array[0...3]
print("获取区间元素组成的新数数组[1, 2, 3, 4] ", sunArray)
//获取数组的第一个元素
var b = array.first
print("获取数组的第一个元素 ", array)
//获取数组的最后一个元素
var c = array.last
print("获取数组的最后一个元素 ", array)
//修改数组中某个位置的元素
array[0] = 0
print("修改数组中某个位置的元素 ", array)
//修改数组中区间范围的元素
array[0...3] = [1, 2, 3]
print("修改数组中区间范围的元素 ", array)
//向数组中追加一个元素
array.append(10)
print("向数组中追加一个元素 ", array)
//向数组中追加一组元素
array.append(contentsOf: [11, 12, 13])
print("向数组中追加一组元素 ", array)
//向数组的某个位置插入一个元素
array.insert(0, at: 0)
print("向数组的某个位置插入一个元素 ", array)
//向数组中某个位置插入一组元素
array.insert(contentsOf: [-2, -1], at: 0)
print("向数组中某个位置插入一组元素 ", array)
//移除数组中某个位置的元素
array.remove(at: 1)
print("移除数组中某个位置的元素 ", array)
//移除数组中首个位置的元素
array.removeFirst()
print("移除数组中首个位置的元素 ", array)
//移除数组中最后一个元素
array.removeLast()
print("移除数组中最后一个元素 ", array)
//移除前几位元素，参数为要移除的元素个数
array.removeFirst(2)
print("移除前几位元素，参数为要移除的元素个数 ", array)
//移除后几位元素，参数为要移除的元素个数
array.removeLast(2)
print("移除后几位元素，参数为要移除的元素个数 ", array)
//移除一个范围内的元素
array.removeSubrange(0...2)
print("移除一个范围内的元素 ", array)
//替换一个范围内的元素
array.replaceSubrange(0...2, with: [0, 1])
print("替换一个范围内的元素 ", array)
//移除所有元素
array.removeAll()
print("移除所有元素 ", array)
//判断数组中是否包含某个元素
if array.contains(1) {
    print("yes")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

这里需要注意，只有当数组实例为变量时，才可以使用增、删、改等方法，常量数组不能进行与修改相关的操作

//也可以用for-in遍历来获取数组中的元素
//Int型数组
let arrayLet = [0, 1, 2, 3, 4]
//(Int, Int)型数组
let arrayLet2 = [(1, 2), (2, 3), (3, 4)]
//直接遍历数组
for item in arrayLet {
    print(item)
}
//进行数组枚举遍历
for item in arrayLet.enumerated() {
    print(item)
}
//进行数组角标遍历
for index in arrayLet2.indices {
    print(arrayLet2[index], separator: "")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

可以直接对数组实例进行遍历，Swift中的for-in结构和Objective-C中的for-in结构还是有一些区别的，Swift中的for-in结构在遍历数组时会按照顺序进行遍历。数组实例中还有一个enumerated()方法，这个方法会返回一个元组集合，将数组的下标和对应元素返回。开发者也可以通过遍历数组的下标来获取数组中的元素，和String类型不同的是，数组中的下标可以是Int类型，而String中的下标是严格的Index类型，这里需要注意，不要混淆。

数组类型中有一个indices属性，这个属性将返回一个范围（Range），此范围就是数组下标的范围

集合

集合类型不关注元素的顺序，但是其中的元素不可以重复，读者也可以将其理解为一个无序的集合。与数组一样，集合在声明时必须指定其类型，或者对其赋初值，使得编译器可以自行推断出集合的类型

//创建set
var set1:Set<Int> = [1, 2, 3, 4]
var set2 = Set(arrayLiteral: 1, 2, 3, 4)
1
2
3

由于集合并不关注其中元素的顺序，因此通过下标的方式来取值对集合来说不太有意义，但是集合类型依然支持通过下标来获取其中的元素

var set1:Set<Int> = [1, 2, 3, 4]
//获取集合首个元素（顺序不定）
set1[set1.startIndex]
//进行下标移动
//获取某一个下标的后一个元素
set1[set1.index(after: set1.startIndex)]
//获取某个下标后几个元素
set1[set1.index(set1.startIndex, offsetBy: 3)]
1
2
3
4
5
6
7
8
9

集合的下标操作为不可逆的操作，只能向后移动，不能向前移动

var set1:Set<Int> = [1, 2, 3, 4]
//向集合中插入一个元素
set1.insert(5)
//移除集合中的某个元素
set1.remove(1)
//移除集合中的第一个元素
set1.removeFirst()
//移除集合中的某个位置的元素
set1.remove(at: set1.firstIndex(of: 3)!)
//移除集合中的所有元素
set1.removeAll()
1
2
3
4
5
6
7
8
9
10
11
12

在使用remove(at:)方法删除集合某个位置的元素时，需要传入一个集合元素的下标值，通过集合实例的firstIndex(of:)方法可以获取具体某个元素的下标值。需要注意，这个方法将会返回一个Optional类型的可选值，因为要寻找的元素可能不存在，在使用时，开发者需要对其进行拆包操作。

集合还有一个独有的特点：可以进行数学运算，例如交集运算、并集运算、补集运算等

var set3:Set<Int> = [1, 2, 3, 4]
var set4:Set<Int> = [1, 2, 5, 6]
//交集
var setInter = set3.intersection(set4)
//交集的补集
var setEx = set3.symmetricDifference(set4)
//并集
var setUni = set3.union(set4)
//第二个集合的补集
var setSub = set3.subtracting(set4)
1
2
3
4
5
6
7
8
9
10
11

使用比较运算符“==”可以比较两个集合是否相等，当两个集合中的所有元素都相等时，两个集合才相等。集合中还提供了一些方法用于判断集合间的关系

var set5:Set = [1, 2]
var set6:Set = [2, 3]
var set7:Set = [1, 2, 3]
var set8:Set = [1, 2, 3]
//判断是否是某个集合子集
set5.isSubset(of: set7)
//判断是否是某个集合的超集
set7.isSuperset(of: set5)
//判断是否是某个集合的真子集
set5.isStrictSubset(of: set5)
//判断是否是某个集合的真超集
set7.isStrictSuperset(of: set8)
1
2
3
4
5
6
7
8
9
10
11
12
13

var set7:Set = [1, 2, 3]
//遍历元素
for item in set7 {
    print(item)
}
//遍历集合的枚举
for item in set7.enumerated() {
    print(item)
}
//遍历集合的下标
for index in set7.indices {
    print(set7[index])
}
//从大到小排序在遍历集合
for item in set7.sorted(by: >) {
    print(item)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

字典类型

//声明字典[param1: param2]类型， 这种结构用于便是字典类型， param1为键类型，param2为值类型
var dic1:[Int: String]
//这种方式和[:]一样，dic2和dic1为相同类型
var dic2: Dictionary<Int, String>
//字典创建与赋值
dic1 = [1: "1", 2 : "2", 3: "3"]
dic2 = Dictionary(dictionaryLiteral: (1, "1"), (2, "2"), (3, "3"))
//在创建字典时，也可以不显式声明字典类型，可以通过赋初值的方式使编译器自动推断
var dic3 = ["1" : "one"]
//创建空字典
var dic4:[Int: Int] = [:]
var dic5:Dictionary<Int, Int> = Dictionary()
1
2
3
4
5
6
7
8
9
10
11
12
13

在字典中值可以重复，但是键必须唯一

//获取字典中元素个数
dic1.count
//判断字典是否为空
if dict1.isEmpty {
    print("yes")
}




//通过键操作值
//获取值
dict1[2]
//修改值
dict1[1] = "0"
//添加一对新的键值
dic1[4] = "4"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在对某个键进行赋值时，如果这个键存在，则会进行值的更新，如果这个键不存在，则会添加一对新的键值

//对键值进行更新操作
dic1.updateValue("1", forKey:1)
1
2
3

updateValue(value:forkey:)方法用于更新一个已经存在的键值对，其中第1个参数为新值，第2个参数为要更新的键

这个方法在执行时会返回一个Optional类型的值，如果字典中此键存在，则会更新成功，并将键的旧值包装成Optional值返回，如果此键不存在，则会返回nil

if let oldValue = dic1.updateValue("one", forKey: 1) {
    print("Yes")
}
1
2
3
4