一、Swift数组
Swift数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。
Swift数组会强制检测元素的类型，如果类型不同则会报错，Swift数组应该遵循像Array<Element>这样的形式，其中Element是这个数组中唯一允许存在的数据类型。
如果创建一个数组，并赋值给一个变量，则创建的集合就是可以修改的。这意味着在创建数组后，可以通过添加、删除、修改的方式改变数组里的项目。如果将一个数组赋值给常量，数组就不可以更改，并且数组的大小和内容都不可以修改。
1.创建数组
我们可以使用构造语法来创建一个由特定数据类型构成的空数组：
var someArray = [SomeType]()
以下是创建一个初始化大小数组的语法：
var someArray = [SomeType](repeating: InitialValue, count: NumberOfElements);
以下实例创建了一个类型为Int，数量为3，初始值为0的空数组：
var someInts = [Int](repeating: 0, count:3)
以下实例创建了含有三个元素的数组：
var someInts : [Int] = [10, 20, 30]
2.访问数组
我们可以根据数组的索引来访问数组的元素，语法如下：
var someVar = someArray[index]
index索引从0开始，即索引0对应第一个元素，索引1对应第二个元素，以此类推。
我们可以通过以下的实例来学习如何创建、初始化、访问数组：
var someInts = [Int](repeating: 10, count: 3)
var someVar = someInts[0]
print("第一个元素的值\(someVar)")
print("第二个元素的值\(someInts[1])")
print("第三个元素的值\(someInts[2])")
以上程序执行输出结果为：
第一个元素的值 10
第二个元素的值 10
第三个元素的值 10
3.修改数组
你可以使用append()方法或者赋值运算符 += 在数组末尾添加元素，如下所示，我们初始化一个数组，并向其添加元素：
var someInts = [Int]()
someInts.append(20)
someInts.append(30)
someInts += [40]
var someVar = someInts[0]
print("第一个元素的值\(someVar)")
print("第二个元素的值\(someInts[1])")
print("第三个元素的值\(someInts[2])")
以上程序执行输出结果为：
第一个元素的值 10
第二个元素的值 10
第三个元素的值 10
我们也可以通过索引修改数组元素的值：
var someInts = [Ints]()
someInts.append(20)
someInts.append(30)
someInts += [40]
someInts[2] = 50 //修改最后一个元素
var someVar = someInts[0]
print("第一个元素的值\(someVar)")
print("第二个元素的值\(someInts[1])")
print("第三个元素的值\(someInts[2])")
以上程序执行输出结果为：
第一个元素的值 20
第二个元素的值 30
第三个元素的值 50
4.遍历数组
我们可以使用for-in循环来遍历所有数组中的数据项：
var someStrs = [String]()
someStrs.append("Apple")
someStrs.append("Amazon")
someStrs.append("Sony")
someStrs += ["Google"]
for item in someStrs {
print(item)
}
以上程序执行输出结果为：
Apple
Amazon
Sony
Google
如果我们同时需要每个数据项的值和索引值，可以使用String的enumerate()方法来进行数组遍历。实例如下：
var someStrs = [String]()
someStrs.append("Apple")
someStrs.append("Amazon")
someStrs.append("Sony")
someStrs += ["Google"]
for (index, item) in someStrs.enumerated() {
print(“在 index = \(index) 位置上的值为 \(item)”)
}
以上程序执行的输出结果为：
在 index = 0 位置上的值为 Apple
在 index = 1 位置上的值为 Amazon
在 index = 2 位置上的值为 Sony
在 index = 3 位置上的值为 Google
5.合并数组
我们可以使用加法（“+”）操作符来合并两种已存在的相同类型数组。新数组的数据类型会从两个数组的数据类型中推断出来：
var intsA = [Int](repeating: 2, count: 2)
var intsB = [Int](repeating: 1, count: 3)
var intsC = intsA + intsB
for item in intsC {
print(item)
}
以上程序执行输出结果为：
2
2
1
1
1
6.count属性
我们可以使用count属性来计算数组元素个数：
var intsA = [Int](count: 2, repeatedValue: 2)
var intsB = [Int](count: 3, repeatedValue: 1)
var intsC = intsA + intsB
print("intsA元素个数为\(intsA.count)")
print("intsB元素个数为\(intsB.count)")
print("intsC元素个数为\(intsC.count)")
以上程序执行输出结果为：
intsA元素个数为 2
intsB元素个数为 3
intsC元素个数为 5
7.isEmpty属性
我们可以通过只读属性isEmpty来判断数组是否为空，返回布尔值：
var intsA = [Int](count: 2, repeatedValue: 2)
var intsB = [Int](count: 3, repeatedValue: 1)
var intsC = [Int]()
print("intsA.isEmpty = \(intsA,isEmpty)")
print("intsB.isEmpty = \(intsB.isEmpty)")
print("intsC.isEmpty = \(intsC.isEmpty)")
以上程序的执行结果为：
intsA.isEmpty = false
intsB.isEmpty = false
intsC.isEmpty = true
二、Swift字典
Swift字典用来存储无序的相同类型数据的集合，Swift字典会强制检测元素的类型，如果类型不同则会报错。
Swift字典每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。
和数组中数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键盘）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。
Swift字典的key没有类型显示可以是整型或字符串，但必须是唯一的。
如果创建一个字典，并赋值给一个变量，则创建的字典就是可以修改的。这意味着在创建字典后，可以通过添加、删除、修改的方式改变字典里的项目。如果一个字典赋值给常量，字典就不可以修改，并且字典的大小和内容都不可以修改。
1.创建字典
我们可以使用以下语法来创建一个特定类型的空字典：
var someDict = [KeyType: valueType]()
以下是创建一个空字典，键的类型为Int，值的类型为String的简单语法：
var someDict = [Int: String]()
以下为创建一个字典的实例：
var someDict : [Int : String] = [1 : "One", 2 : "Two", 3 : "Three"]
2.访问字典
我们可以根据字典的索引来访问数组的元素，语法如下：
var someVar = someDict[key]
我们可以通过以下实例来学习如何创建，初始化，访问字典：
var someDict : [Int : String] = [1 : "One", 2 : "Two", 3 : "Three"]
var someVar = someDict[1]
print("key = 1的值为\(someVar)")
print("key = 2的值为\(someDict[2])")
print("key = 3的值为\(someDict[3])")
以上程序执行输出结果为：
key = 1 的值为 Optional("One")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")
3.修改字典
我们可以使用updateValue(forKey:)增加或更新字典的内容。如果key不存在，则添加值，如果存在则修改key对应的值。updateValue(_:forkey:)方法返回Optional值，实例如下：
var someDict : [Int : String] = [1 : "One", 2 : "Two", 3 : "Three"]
var oldVal = someDict.updateValue("One新的值", forKey: 1)
var someVar = someDict[1]
print("key = 1 旧的值\(oldVal)")
print("key = 1 的值为\(someVar)")
print("key = 2 的值为\(someDict[2])")
print("key = 3 的值为\(someDict[3])")
以上程序执行输出结果为：
key = 1 旧的值Optional("One")
key = 1 的值为Optional("One新的值")
key = 2 的值为Optional("Two")
key = 3 的值为Optional("Three")
你也可以通过指定的key来修改字典的值，如下图所示：
var someDict : [Int : String] = [1 : "One", 2 : "Two", 3 : "Three"]
var oldVal = someDict[1]
someDict[1] = "One 新的值"
var someVar = someDict[1]
print("key = 1 旧的值\(oldVal)")
print("key = 1 的值为 \(someVar)")
print("key = 2 的值为\(someDict[2])")
print("key = 3 的值为\(someDict[3])")
以上程序执行输出结果为：
key = 1 旧的值 Optional("One")
key = 1 的值为 Optional("One 新的值")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")
4.移除Key-Value对
我们可以使用removeValueForKey()方法来移除字典key-value对。如果key存在该方法返回移除的值，如果不存在返回nil。实例如下：
var someDict : [Int : String] = [1 : "One", 2 : "Two", 3 : "Three"]
var removedValue = someDict.removeValue(forKey : 2)
print( "key = 1 的值为 \(someDict[1])" )
print( "key = 2 的值为 \(someDict[2])" )
print( "key = 3 的值为 \(someDict[3])" )
以上程序执行结果为：
key = 1 的值为 Optional("One")
key = 2 的值为 nil
key = 3 的值为 Optional("Three")
你也可以通过指定键的值为 nil 来移除 key-value（键-值）对。实例如下:
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
someDict[2] = nil
print( "key = 1 的值为 \(someDict[1])" )
print( "key = 2 的值为 \(someDict[2])" )
print( "key = 3 的值为 \(someDict[3])" )
以上程序执行输出结果：
key = 1 的值为 Optional("One")
key = 2 的值为 nil
key = 3 的值为 Optional("Three")
5.遍历字典
我们可以使用 for-in 循环来遍历某个字典中的键值对。实例如下:
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
for (key, value) in someDict {
print("字典 key \(key) - 字典 value \(value)")
}
以上程序执行输出结果为：
字典 key 2 - 字典 value Two
字典 key 3 - 字典 value Three
字典 key 1 - 字典 value One
我们也可以使用enumerate()方法来进行字典遍历，返回的是字典的索引及 (key, value) 对，实例如下:
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
for (key, value) in someDict.enumerate() {
print("字典 key \(key) - 字典 (key, value) 对 \(value)")
}
以上程序执行输出结果为：
字典 key 0 - 字典 (key, value) 对 (2, "Two")
字典 key 1 - 字典 (key, value) 对 (3, "Three")
字典 key 2 - 字典 (key, value) 对 (1, "One")
6.字典转换为数组
你可以提取字典的键值（key-value）对，并转换为独立的数组。实例如下：
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
let dictKeys = [Int](someDict.keys)
let dictValues = [String](someDict.values)
print("输出字典的键(key)")
for (key) in dictKeys {
print("\(key)")
}
print("输出字典的值(value)")
for (value) in dictValues {
print("\(value)")
}
以上程序执行输出结果为：
输出字典的键(key)
2
3
1
输出字典的值(value)
Two
Three
One
7.count属性
我们可以使用只读的 count 属性来计算字典有多少个键值对：
var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someDict2:[Int:String] = [4:"Four", 5:"Five"]
print("someDict1 含有 \(someDict1.count) 个键值对")
print("someDict2 含有 \(someDict2.count) 个键值对")
以上程序执行输出结果为：
someDict1 含有 3 个键值对
someDict2 含有 2 个键值对
8.isEmpty属性
Y我们可以通过只读属性 isEmpty 来判断字典是否为空，返回布尔值:
var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someDict2:[Int:String] = [4:"Four", 5:"Five"]
var someDict3:[Int:String] = [Int:String]()
print("someDict1 = \(someDict1.isEmpty)")
print("someDict2 = \(someDict2.isEmpty)")
print("someDict3 = \(someDict3.isEmpty)")
以上程序执行输出结果为：
someDict1 = false
someDict2 = false
someDict3 = true
网友评论