Swift语法基础：16 - Swift的数组, 字典

在Swift中也有一个专门的数组,它不同于OC中的NSArray或者是NSMutableArray,在Swift中,数据要存入数组之前必须要非常的明确,方式通过显式的类型标注,而不是Class类型,比如:

1.数组构造语句

let i: [Int] = [1,2,3,4,5]

这个数组类型是Int类型的,所以只能存储 Int 类型的参数,和元组不一样,元组是可以存储不同类型的数据.

PS: 这里使用的例子是用 let 声明的,所以后续是不可以再添加元素,如果是以 var 开头的话,是可以后续再添加的.

2.访问和修改数组

我们可以通过数组的方法和属性来访问和修改数组,或者下标语法。 还可以使用数组的只读属性 count 来获取数组中的数据项数量。

println("The shopping list contains \(str3.count) items.")
// 打印出来的结果: The shopping list contains 6 items.

使用布尔项 isEmpty 来作为检查 count 属性的值是否为 0 的捷径。

var str: [String] = ["a","b","c"]
let str2: [String] = ["d","e","f"]
var str3 = str + str2

if str3.isEmpty {
    println("The shopping list is empty.")
} else {
    println("The shopping list is not empty.")
}
// 打印出来的结果: The shopping list is not empty.

由于 str3 非空,所以打印出来的结果是The shopping list is empty

如果要给数组添加元素的话,可以通过下面的方法:

str3.append("g")
println(str3)
// [a,b,c,d,e,f,g]

也可以通过加法赋值运算来对数组进行修改:

str3 += ["h","i","j"]
println(str3)
// 打印出来的结果: [a,g,h,i,j]

如果要取出数组里面的某个元素,我们得以下面的方法来做:

var str4 = str3[0]
println(str4)
// 打印出来的结果: a

在这里,数组的元素起始位置和OC是一样的,都是从 0 开始.

我们也可以通过取出数组的元素位置来进行修改,比如:

str3[0] = "Hello"
println(str3)
// 打印出来的结果: [Hello,j]

我们也可以利用区间来对数组元素进行修改:

str3[1...4] = ["Hello","World"]
println(str3)
// 打印出来的结果: [Hello,Hello,World,j]

PS: 我们不能使用下标语法在数组尾部添加新项。如果我们试着用这种方法对索引越界的数据进行检索或者设置新值的操作,我们会引发一个运行期错误。我们可以使用索引值和 数组的 count 属性进行比较来在使用某个索引之前先检验是否有效。除了当 count 等于 0 时(说明这是个空数组),最大索引值一直是 count - 1,因为数组都是零起索引。

我们也可以把内容添加到指定的索引值里,比如:

str3.insert("Cain",atIndex: 0)
println(str3)
// 打印出来的结果: [Cain,j]

有添加,当然也会有删除的,下面让我们来看看删除的方法:

let str5 = str3.removeAtIndex(0)
println("\(str5),\(str3)")
// 打印出来的结果: Cain,[Hello,j]

经过删除之后,我们数组里的第一个元素就会变回我们之前设置的那样,比如:

let firstItem = str3[0]
println(firstItem)
// 打印出来的结果: Hello

3.数组的遍历

数组的遍历非常的简单,这里就不多说了,直接看例子:

let str: [String] = ["a","c","d","e"]

for i in str {
    println(i)
}
// 打印出来的结果: a,e

如果有详细数据的要求,我们可以这么做:

for (index,value) in enumerate(str) {
    println("Item\(index + 1),\(value)")
}
//打印出来的结果: Item1,a,Item2,Item3,Item4,Item5,e

4.创建并且构造一个数组

现在我们来详细来构造一下数组:

var someInts = [Int]()
println("someInts is of type Int[] with \(someInts.count) items。")
// 打印出来的结果: someInts is of type Int[] with 0 items。

上面创建出来的数组是一个空的数组,现在让我们来看看后续怎么对这个数组进行操作:

someInts.append(3)
println(someInts)
// 打印出来的结果: [3]
someInts = []
println(someInts)
// 打印出来的结果: []

解释一下,在somInts后面加了 .append(3),那么数组里就有一个元素,后面someInts = [],的意思就是把数组清空,所以打印出来的结果就是空的.

我们还有另一种创建的方法,比如:

var threeDoubles = [Double](count: 3,repeatedValue:0.0)
println(threeDoubles)
// 打印出来的结果: [0.0,0.0,0.0]

PS: 这种创建方式比较的单一,只能创建多个相同的元素.

但是我们可以这么做:

var anotherThreeDoubles = Array(count: 3,repeatedValue: 2.5)
var sixDoubles = threeDoubles + anotherThreeDoubles

println(sixDoubles)
// 打印出来的结果: [0.0,2.5,2.5]

5.字典

在Swift中也有字典,字典的存储方式也是以键值对方式存储的,而且都是一对一的关系,不会一个键对应多个值,或者一个值对应多个键,和数组一样,字典在存储之前也必须得先声明确定的键值对,比如:

var airports: Dictionary<String,String> = ["TYO": "Tokyo","DUB": "Dublin"]
println(airports)
// 打印出来的结果: [DUB: Dublin,TYO: Tokyo]

6.读取和修改字典

和数组一样,我们同样是可以对字典进行修改的,比如:

airports["LHR"] = "London"
println(airports)
// 打印出来的结果: [DUB: Dublin,TYO: Tokyo,LHR: London]
airports["LHR"] = "London Heathrow"
println(airports)
// 打印出来的结果: [DUB: Dublin,LHR: London Heathrow]

或者是利用下标语法进行修改:

if let oldValue = airports.updateValue("Dublin Internation",forKey: "DUB") {
    println("The old value for DUB was \(oldValue).")
}
// 打印出来的结果: The old value for DUB was Dublin.

我们也可以使用下标语法来搜索字典里特定的键值对:

if let airportName = airports["DUB"] {
    println("The name of the airport is \(airportName).")
} else {
    println("That airport is not in the airports dictionary.")
}
// 打印出来的结果: The name of the airport is Dublin Internation.

删除字典里的某个键值对:

airports["APL"] = "Apple Internation"
println(airports)
// 打印出来的结果: [DUB: Dublin,APL: Apple Internation]
airports["APL"] = nil
println(airports)
// 打印出来的结果: [DUB: Dublin,TYO: Tokyo]

我们还可以利用下标语法对字典里特定的键值对进行删除:

if let removedValue = airports.removeValueForKey("DUB") {
    println("The removed airport's name is \(removedValue).")
} else {
    println("The airports dictionary does not contain a value for DUB.")
}
// 打印出来的结果: The removed airport's name is Dublin.

7.遍历字典

在Swift里遍历字典是一件非常爽的事情,和OC完全不一样,快速简单多了,让我们来看看:

for (airportCode,airportName) in airports {
    println("\(airportCode): \(airportName)")
}
// 打印出来的结果: DUB: Dublin,TYO: Tokyo

没错,你没看错,在Swift中遍历字典就这两行代码,非常的快速简单,爽爆了.

同样的,我们也可以只遍历键,或者是值:

for airportCode in airports.keys {
    println("Airport code: \(airportCode)")
} // 打印出来的结果: Airport code: DUB,Airport code: TYO

for airportName in airports.values {
    println("Airport name: \(airportName)")
} // 打印出来的结果: Airport name: Dublin,Airport name: Tokyo

同样是非常的爽,这里就让各位回去自己试试看,对比一下OC和Swift的区别了.

在这里,我们可以通过键或者值创建出一个新的数组,比如:

let airportCodes = Array(airports.keys)
println(airportCodes)
// 打印出来的结果: [DUB,TYO]

let airportNames = Array(airports.values)
println(airportNames)
// 打印出来的结果:[Dublin,Tokyo]

8.创建空的字典

和数组一样,我们也可以创建一个空的字典,比如:

var namesOfIntegers = Dictionary<Int,String>()
println(namesOfIntegers)
// 打印出来的结果: [:]

我们可以后续给它添加键值对,比如:

namesOfIntegers[1] = "a"
println(namesOfIntegers)
// 打印出来的结果: [1 : a]

同样的,我们也可以给字典清零:

namesOfIntegers = [:]
println(namesOfIntegers)
// 打印出来的结果: [:]

9.集合的可变性

数组和字典都是在单个集合中存储可变值。如果我们创建一个数组或者字典并且把它分配成一个变量,这个集合将会是可变的。这意味着我们可以在创建之后添加更多或移除已存在的 数据项来改变这个集合的大小。与此相反,如果我们把数组或字典分配成常量,那么他就是 不可变的,它的大小不能被改变。

对字典来说,不可变性也意味着我们不能替换其中任何现有键所对应的值。不可变字典的内 容在被首次设定之后不能更改。 不可变行对数组来说有一点不同,当然我们不能试着改变 任何不可变数组的大小,但是我们可以重新设定相对现存索引所对应的值。这使得 Swift 数组在大小被固定的时候依然可以做的很棒。

PS: 在我们不需要改变数组大小的时候创建不可变数组是很好的习惯。如此 Swift 编译 器可以优化我们创建的集合。

好了,这次我们就讲到这里,下次我们继续~