和Java差异的语法,集合类型

这一片段的重点内容是斯维夫特中的Collections

这一有的的主要性内容是Swift中的Collections

集合类型 (Collection Types)

自打苹果201四年发布斯维夫特,到现行反革命已经两年多了,而Swift也来到了三.壹本子。二〇一八年应用工作之余,共花了七个多月的时光把官方的Swift编制程序指南看完。未来整理一下笔记,回看一下在先的学问。有亟待的同学能够去看合法文书档案>>。


Swift提供了三种集合类型:数组(Array)、集合(Set)、字典(Dictionary)。Array是有各种的值的汇集;Set是多个唯一的值的冬天聚集;Dictionary是冬日的键值对聚集。

注意:Swift的ArraySetDictionary都属于泛型集合。

Swift提供ArraysSetsDictionaries两种为主的聚合类型用来囤积集合数据。

大家精晓Java中的Collection基本上是每五个Java程序猿接触到的第二个基本点的知识点。

我们领悟Java中的Collection基本上是每个Java程序猿接触到的首先个重大的知识点。

数组 (Array)

数组只好存款和储蓄一样档次的值。同样的值能够出现在数组的不等岗位中。

1. 数组

数组使用有类别表存款和储蓄同1类型的两个值,一样的值能够屡屡面世。

在斯威夫特中也不例外,斯威夫特中的Collection有八个:数组(Array),字典(Dictionary)和聚众(set)

在斯威夫特中也不例外,Swift中的Collection有八个:数组(Array),字典(Dictionary)和聚集(set)

数组类型的笔记语法 (Array Type Shorthand Syntax)

2个数组的档次是那样写的:Array<Element>和Java差异的语法,集合类型。,Element是数组成分值的种类,也足以简写成:[Element]

1.一 成立2个空数组

var someInts = [Int]()

一、数组

一、数组

创制二个空数组 (Creating an Empty Array)
var someInt = [Int]()
print("someInts is of type [Int] with \(someInts.count) items.")
// Prints "someInts is of type [Int] with 0 items."

someInt被估量为[Int]类型。

一旦上下文已经提供了数组的种类,空素组还足以写成[]

someInt.append(3)
// someInts now contains 1 value of type Int
someInt = []
// someInts is now an empty array, but is still of type [Int]

一.二 创造三个饱含暗许值得数组

var threeDoubles = Array(repeating: 0.0, count: 3)
// 等价于[0.0, 0,0, 0.0]

数组的创造方法,请参见其余一篇小说Swift三中数组创立方法,那里要说的是Swift中有的数组的性状:

数组的成立方法,请参见别的一篇作品Swift三中数组创设方法,那里要说的是斯威夫特中有的数组的特征:

创造贰个有暗许值的数组 (Creating an Array with a Default Value)
var threeDoubles = Array(repeating: 0.0, count: 3)
// threeDoubles is of type [Double], and equals [0.0, 0.0, 0.0]

1.三 通过多个数组相加创立3个数组

var anotherThreeDoubles = Array(repeating: 2.5, count: 3)
var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles被推断为[Double]

壹、向数组中添英镑素:

1、向数组中添欧成分:

经过统一四个数组来创设数组 (Creating an Array by Adding Two Arrays Together)
let anotherThreeDoubles = Array(repeating: 2.5, count: 3)
// anotherThreeDoubles is of type [Double], and equals [2.5, 2.5, 2.5]

var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles is inferred as [Double], and equals [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

一.四 用数组字面量构造数组

var shoppingList:[String] = ["Eggs", "Milk"]
// shoppingList已经被构造并且拥有两个初始项

由于Swift的品类推测机制,当大家用字面量构造只具备同样档次值数组的时候,可以省却数组的门类:

var shoppingList = ["Eggs", "Milk"]

向数组中添美金素除了能够行使append方法,使用+也是能够的:

向数组中添英镑素除了能够应用append方法,使用+也是足以的:

用字面值创设数组 (Creating an Array with an Array Literal)
var shoppingLis = ["Eggs", "Milk"]
// shoppingList has been initialized with two initial items

一.五 访问和修改数组

  • count:获取数组中的成分数目
  • isEmpty:检查count是否为0
  • append(_:):在数组后面增多新的数码
  • insert(_:at:):在有些具体索引值此前增加数据项
  • remove(at:):移除数组中的某壹项
  • removeLast():移除数组的结尾1项

+=运算符能够一直在数组前面加多2个或几个同类别的数据项:

shoppingList += ["Baking Powder"]
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]

我们能够经过下标获取或改换某些已有索引值对应的数额。
仍是能够运用下标来3次变动一雨后春笋的数据值:

shoppingList[4..<6] = ["Bananas", "Apples"]
var numbers = [1,2,3,4,5]
numbers.append(8)
numbers+[8]
var numbers = [1,2,3,4,5]
numbers.append(8)
numbers+[8]
做客和退换数组 (Accessing and Modifying an Array)

获得数组的个数:

print("The shopping list contains \(shoppingList.count) items.")
// Prints "The shopping list contains 2 items."

看清数组成分的个数是不是为0:

if shoppingList.isEmpty {
    print("The shopping list is empty.")
} else {
    print("The shopping list is not empty.")
}

充实一个成分:

shoppingList.append("Flour")
// shoppingList now contains 3 items, and someone is making pancakes

选拔加法赋值运算符增添越多因素:

shoppingList += ["Baking Powder"]
// shoppingList now contains 4 items
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList now contains 7 items

利用下标获取成分:

var firstItem = shoppingList[0]
// firstItem is equal to "Eggs"

改变成分:

shoppingList[0] = "Six eggs"
// the first item in the list is now equal to "Six eggs" rather than "Eggs"

行使下标二次性更换三个元素,甚至要改换的因素个数能够不等于新数组的个数:

shoppintList[4...6] = ["Bananas", "Apples"]
// 用两个替换三个

在特定的岗位插入成分:

shoppingList.insert("Maple syrup", at: 0)
// shoppingList now contains 7 items
// "Maple Syrup" is now the first item in the list

删去特定岗位的成分,并且再次回到被剔除的因素:

let mapleSyrup = shoppingList.remove(at: 0)
// the item that was at index 0 has just been removed
// shoppingList now contains 6 items, and no Maple Syrup
// the mapleSyrup constant is now equal to the removed "Maple Syrup" string

去除最终四个成分:

let apples = shoppingList.removeLast()
// the last item in the array has just been removed
// shoppingList now contains 5 items, and no apples
// the apples constant is now equal to the removed "Apples" string

壹.陆 数组的遍历

作者们能够用for-in循环遍历全数数组中的数据项。
设若大家还要需求各种数据项的值和索引值,能够使用enumerated()方法。enumerated()回去2个由种种多少项索引值和数据值组成的元组:

for (index, value) in shoppingList.enumerated() {
    print("Item \(String(index + 1)): \(value)")
}

都以足以的。

都以能够的。

遍历整个数组 (Iterating Over an Array)

使用for-in遍历:

for item in shoppingList {
    print(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas

使用enumerated()方法遍历,那么些点子重临包括索引和目录对应的要素的多元组:

for (index, value) in shoppingList.enumerated() {
    print("Item \(index + 1): \(value)")
}
// Item 1: Six eggs
// Item 2: Milk
// Item 3: Flour
// Item 4: Baking Powder
// Item 5: Bananas

2. 集合

聚拢用来囤积同样档次并且未有分明顺序的值,集合内的因素不可能再一次。

二、四个数组相等

2、七个数组相等

集合 (Sets)

聚拢中无顺序地蕴藏了一样体系的值,并且个中的每一个值都是绝无仅有的。在要素的次第不重大恐怕要求每贰个要素都急需唯壹的时候,可以接纳集合,而不用数组。

二.一 集合类型的哈希值

储存在集结中的类型必须是可哈希化的,Swift的富有骨干项目(比如String,Int,DoubleBool)暗许都以可哈希化的,未有涉嫌值额枚举成员值暗中认可也是可哈希化的。

你能够使用自定义的花色作为集合的值的花色或字典的键的档次,但需求使自定义类型符合Swift标准库中的Hashable澳门葡京备用网址,协议。符合Hashable协和式飞机的品类要求提供3个项目为Int的可读属性hashValue

在Java和C/C++中判别多个数组相等是相比复杂的,可是在Swift中却很有益于:

在Java和C/C++中推断七个数组相等是比较复杂的,可是在斯威夫特中却很方便:

会面类型的哈希值 (Hash Values for Set Types)

集聚里面包车型地铁要素类型必须hashable,也正是说,那几个因素类型必须提供三个方式来测算他自身的哈希值。三个哈希值是2个用来判断八个目的是还是不是等于的Int项指标平头。例如,假使a == b,那么a.hashValue == b.hashValue

有着斯维夫特的为主项目(例如StringIntDoubleBool)暗许都以hashable的,都能够作为集合的值类型恐怕字典的键类型。未有关联值的枚举值暗中同意也是hashable的。

大家得以自定义类型,并且遵照Hashable磋商,作为集合或然字典键的值类型。自定义的品类必须提供二个能读取的Int品类的品质,并取名叫hashValue。在不一致的主次如故同二个程序运维很多次中,不须求每便hashValue性情重回的值都等于。

因为Hashable协议遵循Equatable研讨,所以大家自定义的档次还亟需提供四个对等运算符(==)的实现。Equatable商业事务须求每一个==的兑现是三个等价关系。也等于说,==的落实必须满意上面多个标准化:

  • a == a (自反性)
  • a == b,说明b == a (对称性)
  • a == b && b == c,说明 a == c (传递性)

二.二 集合类型语法

var numbers = [1,2,3,4,5]
var oneToFive = [1,2,3,4,5]
numbers == oneToFive
var numbers = [1,2,3,4,5]
var oneToFive = [1,2,3,4,5]
numbers == oneToFive
汇聚类型语法 (Set Type Syntax)

使用Set<Element>来安装集合类型,Element是集结存款和储蓄的要素类型。

2.贰.一 创立和结构二个空的汇聚

var letters = Set<Character>()

以此再次回到值正是true,直接用==就足以拓展剖断了。

其一再次来到值就是true,直接用==就能够打开决断了。

创制和初始化三个空集合 (Creating and Initializing an Empty Set)
var letters = Set<Character>()
print("letters is of type Set<Character> with \(letters.count) items.")
// Prints "letters is of type Set<Character> with 0 items."

letters被估算为Set<Character>类型。

同等地,要是上下文提供了集聚的类型音信,能够利用[]来创立3个空的成团:

letters.insert("a")
// letters now contains 1 value of type Character
letters = []
// letters is now an empty set, but is still of type Set<Character>

二.贰.二 用数组字面量创立集合

var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]

二、字典和聚合

二、字典和集聚

运用数组字面值来创立五个集合 (Creating a Set with an Array Literal)
var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
// favoriteGenres has been initialized with three initial items

聚拢的品类不可能通过数组的字面值来揣摸,所以Set的品种必须精通宣称。可是因为斯维夫特的花色推断,借使用两个暗含同样档次字面值的数组来初步化集合,我们能够不写集合的体系。例如:

var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]

因为数组的百分百字面值都是平等档次,所以Swfit能测度出Set<String>favoriteGenres的科学类型。

二.2.三 访问和改造三个集聚

  • count:返回Set凉月素的数据
  • isEmpty:检查count是否为0
  • insert(_:):加多三个新因素
  • remove(_:):删除一个成分(假诺Set不分包该值,再次来到nil)
  • removeAll():删除全部因素
  • contains(_:):检查Set中是或不是含有三个特定的值

对字典和聚集来讲最器重的是开创方法,其余的在法定文书档案都得以查到(当然成立方法也是足以查到的)

对字典和聚众来说最注重的是创设方法,其余的在合法文书档案都得以查到(当然制造方法也是足以查到的)

走访和修改集合 (Accessing and Modifying a Set)

使用count特性获取集合元素个数:

print("I have \(favoriteGenres.count) favorite music genres.")
// Prints "I have 3 favorite music genres."

使用isEmpty品质剖断集合桐月素的个数是还是不是为0:

if favoriteGenres.isEmpty {
    print("As far as music goes, I'm not picky.")
} else {
    print("I have particular music preferences.")
}
// Prints "I have particular music preferences."

使用insert(_:)艺术添法郎素:

favoriteGenres.insert("Jazz")
// favoriteGenres now contains 4 items

使用remove(_:)去除三个因素,并赶回被剔除的要素,假若成分不存在,再次回到nil;使用removeAll()剔除全数要素:

if let removedGenre = favoriteGenres.remove("Rock") {
    print("\(removedGenre)? I'm over it.")
} else {
    print("I never much cared for that.")
}
// Prints "Rock? I'm over it."

剖断是或不是包蕴有个别成分:

if favoriteGenres.contains("Funk") {
    print("I get up on the good foot.")
} else {
    print("It's too funky in here.")
}
// Prints "It's too funky in here."

贰.2.四 遍历四个集合

使用for-in遍历二个凑合。
Swift的Set花色未有规定的依次,为了依据一定的依次来遍历二个Set中的值能够用sorted()艺术,它将回来1个平稳数组,那些数组的因素排列顺序又操作符<对成分实行相比较的结果来明确。

for genre in favoriteGenres.sorted() {
    print("genre")
}
// 按顺序打印"Classical", "Hip hop", "Jazz"

字典的创设:

字典的创制:

遍历整个集合 (Iterating Over a Set)
for genre in favoriteGenres {
    print("\(genre)")
}
// Jazz
// Hip hop
// Classical

Swift的相会类型未有定义顺序,大家得以应用sorted()办法来排序,这一个点子运用<运算符将成分从小到大排列:

for genre in favoriteGenres.sorted() {
    print("\(genre)")
}
// Classical
// Hip hop
// Jazz

二.叁 集合操作

var dic = ["apple" : "苹果", "bag" : "包"]
var dic = ["apple" : "苹果", "bag" : "包"]

试行集合操作 (Performing Set Operations)

贰.三.1 基本集合操作

  • intersection(_:):依照多个汇集中都含有的值创制3个新的集结
  • symmetricDifference(_:):依据在一个集结中但不在多个汇集中的值创建三个新集合
  • union(_:):依据多个聚众的值创立3个新集合
  • subtracting(_:):根据不在该集合中的值成立二个新集合

let oddDigits: Set = [1, 3, 5, 7, 9]
let evenDigits: Set = [0, 2, 4, 6, 8]
let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]

oddDigits.union(evenDigits).sorted()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

oddDigits.intersection(evenDigits).sorted()
// []

oddDigits.subtracting(singleDigitPrimeNumbers).sorted()
// [1, 9]

oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted()
// [1, 2, 9]

会晤的创制:

聚集的创始:

核心集合操作 (Fundamental Set Operations)

下图是集聚ab执行了不一样的点子之后,得出的结果图:

澳门葡京备用网址 1

Fundamental Set Operations

  • 使用intersection(_:)格局获得八个聚众共有的元素,并用那几个一样的因素成立贰个新的联谊
  • 使用symmetricDifference(_:)措施得到除了多少个汇聚共有的要素外的装有因素,并用这么些一样的成分创造三个新的聚合
  • 使用union(_:)主意得到七个汇集的全体因素,并用那么些同样的因素创立三个新的集结
  • 使用subtracting(_:)方法减去与钦点集合一样的要素后剩余的要素,并用剩下的成分创制二个新的集纳

let oddDigits: Set = [1, 3, 5, 7, 9]
let evenDigits: Set = [0, 2, 4, 6, 8]
let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]

oddDigits.union(evenDigits).sorted()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
oddDigits.intersection(evenDigits).sorted()
// []
oddDigits.subtracting(singleDigitPrimeNumbers).sorted()
// [1, 9]
oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted()
// [1, 2, 9]

贰.3.二 集合成员涉及和出色

  • ==:剖断八个聚众是不是等于
  • isSubset(of:):决断二个集合中的值是还是不是也被含有在另一个凑合中
  • isStrictSubset(of:)/isStrictSuperset(of:):判定2个汇集是或不是是另2个集聚的子集合/父集合并且多个汇聚不对等
  • isDisjoint(with:):剖断那三个聚众是不是有搅和

let houseAnimals: Set = ["dog", "cat"]
let farmAnimals: Set = ["cow", "chicken", "sheep", "dog", "cat"]
let cityAnimals: Set = ["bird", "mouse"]

houseAnimals.isSubset(of: farmAnimals)
// true

farmAnimals.isSuperset(of: houseAnimals)
// true

farmAnimals.isDisjoint(with: cityAnimals)
// ture
var letters = Set<Character>()
var setColors:Set<String> = ["红色","白色","洋红色","黄色"]
var letters = Set<Character>()
var setColors:Set<String> = ["红色","白色","洋红色","黄色"]
聚拢关系和格外性 (Set Membership and Equality)

下图演示了八个汇聚:abc,重叠区域代表有一样的成分。集合a是集合b的父集合,因为a包含了b的兼具因素;相反,ba的子集合。集合b和集合c互不相交,因为她俩从未同样的要素。

澳门葡京备用网址 2

Set Membership and Equality

  • 行使“是还是不是等于”运算符 (==)来判定多个汇聚的有所因素是还是不是等于
  • 使用isSubset(of:)艺术判定集合的兼具因素是或不是含有于钦赐集合
  • 使用isSuperset(of:)办法剖断集合是还是不是含有钦点集合的全体因素
  • 使用isStrictSubset(of:)或者isStrictSuperset(of:)方式决断集合是还是不是子集合也许父集合,可是不对等钦赐的聚合
  • 使用isDisjoint(with:)主意判定八个集聚是或不是有一致的因素

let houseAnimals: Set = ["🐶", "🐱"]
let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
let cityAnimals: Set = ["🐦", "🐭"]

houseAnimals.isSubset(of: farmAnimals)
// true
farmAnimals.isSuperset(of: houseAnimals)
// true
farmAnimals.isDisjoint(with: cityAnimals)
// true

3. 字典

字典是一种存款和储蓄八个一样类其他值得容器,字典中的数据项尚未现实顺序。

 

 

Dictionaries (字典)

字典是2个无序聚集中1律档次的键和一样档次的值的关系。每一个值关联着3个唯1的键。

3.一 创造四个空字典

var namesOfIntegers = [Int: String]()

内需小心的是:

亟需注意的是:

字典类型速记语法 (Dictionary Type Shorthand Syntax)

使用Dictionary<Key, Value>来内定字典的门类。

注意:字典的Key连串必须比照Hashable商量,就如集合的值一样。

还是能是用简短的情势[Key: Value]来钦赐字典的类型.

叁.贰 用字典字面量创立字典

var airports: [String: String] = ["XYZ": "Toronto Pearson", "DUB": "Dublin"]

var airports = ["XYZ": "Toronto Pearson", "DUB": "Dublin"]

数组:有序的

数组:有序的

成立一个空字典 (Creating an Empty Dictionary)
var namesOfIntegers = [Int: String]()
// namesOfIntegers is an empty [Int: String] dictionary

要是上下文已经提供了类型音讯,能够采用[:]来创造二个空字典:

namesOfIntegers[16] = "sixteen"
// namesOfIntegers now contains 1 key-value pair
namesOfIntegers = [:]
// namesOfIntegers is once again an empty dictionary of type [Int: String]

三.三 访问和退换字典

同数组和聚合一样,字典同样具备countisEmpty属性。
大家能够在字典中应用下表语法增添新的多少项,可能转移特定键对应的值。

airports["LHR"] = "London"
airports["LHR"] = "London Heathrow"

updateValue(_:forKey:)全数一样的法力,分裂的是,这么些艺术再次来到更新值从前的原值,即对应值的档次的可选值。

if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {
    print("The old value for DUB was \(oldValue)")
}
// 输出 "The old value for DUB was Dublin

笔者们也足以利用下标语法在字典中检索特定键对应的值。

if let airportName = airports["DUB"] {
    print("The name of the airports is \(airportName)")
} else {
    print("That airport is not in the airports dictionary")
}
// 打印 "The name of the airports is Dublin Airport"

大家还足以行使下标语法通过给某些键的对应值赋值为nil来从字典里移除2个键值对:

airports["APL"] = "Apple Internation"
airports["APL"] = nil

removeValue(forKey:)方式也足以用来移除键值对,重返被移除的值恐怕在一贯不值得情形下重返nil

if let removedValue = airports.removeValue(forKey: "DUB") {
    print("The removed airports name is \(removedValue)")
} else {
    print("The airports dictionary does not contain a value for DUB")
}
// prints "The removed airports name is Dublin Airport"

聚拢:严节的、唯壹的、能够举行联谊操作(交并补),能够完毕迅速找寻

集聚:冬日的、唯1的、能够进行联谊操作(交并补),能够兑现高效找寻

采纳字典字面值来成立字典 (Creating a Dictionary with a Dictionary Literal)
var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]

3.4 字典遍历

除了for-in奇幻遍历,大家也得以通过拜访keys或者values特性,遍历字典的键也许值:

Swift的字典类型是严节聚集类型,为了以特定的顺序遍历字典的键或值,能够对字典的keysvalues属性使用sorted()方法。

字典:键值对

字典:键值对

做客和改换字典 (Accessing and Modifying Dictionary)

收获字典键值对的个数:

print("The airports dictionary contains \(airports.count) items.")
// Prints "The airports dictionary contains 2 items."

看清字典中键值对的个数是还是不是为0:

if airports.isEmpty {
    print("The airports dictionary is empty.")
} else {
    print("The airports dictionary is not empty.")
}
// Prints "The airports dictionary is not empty."

行使下标语法增添新的键值对:

airports["LHR"] = "London Heathrow"
// the value for "LHR" has been changed to "London Heathrow"

还足以使用updateValue(_:forKey:)主意来设置或更新三个键一见钟情的值,并赶回八个可选类型的值。假诺那一个键不设有,那么就增添2个新的键值对,并回到nil;假如那些键存在,那么就更新这些键对应的值,并赶回在此以前的旧值。那足以让我们检查键对应的值是不是更新成功。

if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {
    print("The old value for DUB was \(oldValue).")
}
// Prints "The old value for DUB was Dublin."

动用下标语法来获取键对应的值:

if let airportName = airports["DUB"] {
    print("The name of the airport is \(airportName).")
} else {
    print("That airport is not in the airports dictionary.")
}
// Prints "The name of the airport is Dublin Airport."

使用下标语法并把键对应的值设置为nil来删除一个键值对:

airports["APL"] = "Apple International"
// "Apple International" is not the real airport for APL, so delete it
airports["APL"] = nil
// APL has now been removed from the dictionary

除此以外,还足以行使removeValue(forKey:)格局来删除二个键值对,假设存在,重返键对应的值;假设不存在,再次回到nil

if let removedValue = airports.removeValue(forKey: "DUB") {
    print("The removed airport's name is \(removedValue).")
} else {
    print("The airports dictionary does not contain a value for DUB.")
}
// Prints "The removed airport's name is Dublin Airport."
遍历整个字典 (Iterating Over a Dictionary)
for (airportCode, airportName) in airports {
    print("\(airportCode): \(airportName)")
}
// YYZ: Toronto Pearson
// LHR: London Heathrow

使用keysvalues质量来遍历字典的全体键和全体值:

for airportCode in airports.keys {
    print("Airport code: \(airportCode)")
}
// Airport code: YYZ
// Airport code: LHR

for airportName in airports.values {
    print("Airport name: \(airportName)")
}
// Airport name: Toronto Pearson
// Airport name: London Heathrow

倘若要采取字典的全部键和享有值,能够使用数组的API来成立:

let airportCodes = [String](airports.keys)
// airportCodes is ["YYZ", "LHR"]

let airportNames = [String](airports.values)
// airportNames is ["Toronto Pearson", "London Heathrow"]

斯维夫特的字典类型未有定义顺序,为了遍历经过排序的全数键和有着值,必要利用keysvalues属性的sorted()方法。


第六片段完。下个部分:【Swift 3.1】05 – 控制流 (Control Flow)


假若有荒唐的地点,欢迎指正!多谢!

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website