swift 数组sort

Swift 语言提供数组(Array)、集合(Set)和字典(Dictionary)三种基本的集合类型用来存储集合数据。数组是有序数据的集。集合

是无序无重复数据的集。字典是无序的键值对的集。

Swift 中的数组、集合和字典必须明确其中保存的键和值类型，这样就可以避免插⼊一个错误数据类型的值。同理，对于获取到

的值你也可以放心，其数据类型是确定的。

注意

Swift 的数组、集合和字典类型被实现为泛型集合。

 

集合的可变性

如果创建一个数组、集合或字典并且把它分配成一个变量，这个集合将会是可变的。这意味着可以在创建之后添加、修改 或者删

除数据项。如果把数组、集合或字典分配成常量，那么它就是不可变的，它的⼤小和内容都不能被改变。

 

注意

在不需要改变集合的时候创建不可变集合是很好的实践。这样做便于你理解⾃己的代码，也能让 Swift 编译器优化集合的性能。

数组(Arrays)

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

注意

Swift 的 Array 类型被桥接到 Foundation 中的 NSArray 类

 

数组的简单语法 

Swift 中数组的完整写法为 Array<Element> ，其中 Element 是这个数组中唯一允许存在的数据类型。也可以使用像[Element] 

这样的简单语法。尽管两种形式在功能上是一样的，但是推荐较短的那种，而且在本文中都会使用这种形式来使⽤数组。

 

创建一个空数组

你可以使用构造语法来创建一个由特定数据类型构成的空数组:

var someInts = [Int]()
print("someInts is of type [Int] with \(someInts.count) items.")            // 打印“someInts is of type [Int] with 0 items.”

注意，通过构造函数的类型， someInts 的值类型被推断为 [Int] 。 或者，如果代码上下文中已经提供了类型信息，例如一个函

数参数或者一个已经定义好类型的常量或者变量，你可以使用空数组语句创建一个空数组，它的写法很简单: [] (一对空方括号):

someInts.append(3)           // someInts 现在包含一个 Int 值
someInts = []                       // someInts 现在是空数组，但是仍然是 [Int] 类型的。

 

创建一个带有默认值的数组

Swift 中的 Array 类型还提供一个可以创建特定⼤小并且所有数据都被默认的构造⽅法。可以把准备加入新数组的数据项数量( 

count )和适当类型的初始值( repeating )传⼊数组构造函数:

var threeDoubles = Array(repeating: 0.0, count: 3)           // threeDoubles 是一种 [Double] 数组，等价于 [0.0, 0.0, 0.0]

 

 通过两个数组相加创建一个数组

你可以使用加法操作符( + )来组合两个已存在的相同类型数组。新数组的数据类型会从两个数组的数据类型中推断出来:

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

 

⽤数组字面量构造数组

你可以使用数组字面量来进行数组构造，这是一种⽤一个或者多个数值构造数组的简单⽅法。数组字面量是一系列由逗号分割并

由方括号包含的数值:

[value 1, value 2, value 3] 。

下面这个例子创建了一个叫做 shoppingList 并且存储 String 的数组:

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

shoppingList 变量被声明为“字符串值类型的数组“，记作 [String] 。因为这个数组被规定只有 String 一种数据结构，所以只有 

String 类型可以在其中被存取。在这⾥， shoppingList 数组由两个 String 值( "Eggs"和 "Milk" )构造，并且由数组字⾯量定义。

注意

shoppingList 数组被声明为变量( var 关键字创建)而不是常量( let 创建)是因为之后会有更多的数据项被插入其中。

在这个例子中，字⾯量仅包含两个 String 值。匹配了该数组的声明(只能包含 String 的数组)，所以可以将这个字⾯量的赋值过程

看作用两个初始项来构造 shoppingList 的一种⽅式。

由于 Swift 的类型推断机制，当你用字⾯量构造拥有相同类型值数组的时候，不必把数组的类型定义清楚。 shoppingList 的构造

也可以这样写:

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

因为所有数组字⾯量中的值都是相同的类型，Swift 可以推断出 [String] 是 shoppingList 中变量的正确类型。

 

访问和修改数组

你可以通过数组的方法和属性来访问和修改数组，或者使用下标语法。

可以使用数组的只读属性 count 来获取数组中的数据项数量:

print("The shopping list contains \(shoppingList.count) items.")
// 输出“The shopping list contains 2 items.”(这个数组有2个项)

使⽤布尔属性 isEmpty 作为一个缩写形式去检查 count 属性是否为 0 :

if shoppingList.isEmpty {
            print("The shopping list is empty.")
} else {
           print("The shopping list is not empty.")
}
// 打印“The shopping list is not empty.”(shoppinglist 不是空的)

也可以使用 append(_:) ⽅法在数组后面添加新的数据项:

shoppingList.append("Flour")                // shoppingList 现在有3个数据项，似乎有人在摊煎饼

除此之外，也可以使用加法赋值运算符( += )直接将另一个相同类型数组中的数据添加到该数组后面:

shoppingList += ["Baking Powder"]                                                     // shoppingList 现在有四项了
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]             // shoppingList 现在有七项了

可以直接使用下标语法来获取数组中的数据项，把所需要数据项的索引值直接放在数组名称之后的⽅括号中:

var firstItem = shoppingList[0]                    // 第一项是“Eggs”

注意

第一项在数组中的索引值是 0 而不是 1 。 Swift 中的数组索引总是从零开始。

你也可以用下标来改变某个有效索引值对应的数据值:

shoppingList[0] = "Six eggs"             // 其中的第一项现在是“Six eggs”⽽不是“Eggs”

当你使用下标语法，所使用的下标必须是有效的。例如，试图通过 shoppingList[shoppingList.count] = "Salt"在数组的最后添

加一项，将产生一个运行时错误。

还可以利用下标来一次改变一系列数据值，即使新数据和原有数据的数量是不一样的。下⾯的例子把 "Chocolate Spread" 、 

"Cheese" 和 "Butter" 替换为 "Bananas" 和 "Apples" :
shoppingList[4...6] = ["Bananas", "Apples"]                  // shoppingList 现在有6项

通过调用数组的 insert(_:at:) 方法在某个指定索引值之前添加数据项:

shoppingList.insert("Maple Syrup", at: 0)                     // shoppingList 现在有7项
// 现在这个列表中的第一项是“Maple Syrup”

这次 insert(_:at:) 方法调⽤把值为 "Maple Syrup" 的新数据项插入列表的最开始位置，并且使用 0 作为索引值。

类似的可以使用 remove(at:) ⽅法来移除数组中的某一项。这个⽅法把数组在特定索引值中存储的数据项移除并且返回这个被移

除的数据项(不需要的时候就可以无视它):

let mapleSyrup = shoppingList.remove(at: 0)               // 索引值为0的数据项被移除
// shoppingList 现在只有6项，而且不包括 Maple Syrup
// mapleSyrup 常量的值等于被移除数据项“Maple Syrup”

注意

如果你试图通过越界索引来执行访问或者修改数据的操作，会引发一个运行时错误。此时可以使用索引值和数组的 count 属性进

⾏⽐较来在使用该索引之前检验其是否有效。除了当 count 等于 0 时(说明这是个空数组)，最大索引值一直是count - 1 ，因为数

组都是零起索引。

数据项被移除后数组中的空出项会被自动填补，所以现在索引值为 0 的数据项的值再次等于 "Six eggs" :

firstItem = shoppingList[0]                      // firstItem 现在等于“Six eggs”

如果你只想把数组中的最后一项移除，可以使用 removeLast() ⽅法⽽不是 remove(at:) ⽅法来避免需要获取数组的 count 属

性。就像后者一样，前者也会返回被移除的数据项:

let apples = shoppingList.removeLast()              // 数组的最后一项被移除了
// shoppingList 现在只有5项，不包括 Apples
// apples 常量的值现在等于字符串“Apples”

 

数组的遍历

你可以使用 for-in 循环来遍历数组中所有的数据项:

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

如果同时需要每个数据项的值和索引值，可以使用 enumerated() ⽅法来进行数组遍历。 enumerated() 返回一个由索引值和数

据值组成的元组数组。索引值从零开始，并且每次增加一 ; 如果枚举⼀整个数组，索引值将会和数据值一一匹 配。你可以把这个

元组分解成临时常量或者变量来进行遍历:

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