Swift中關於陣列的建立非常簡單，就不過多描述，今天主要學習一下關於陣列的一些操作函式。

1.popLast

*popLast

函式主要功能：移除並返回集合的最後一個元素。

var character = ["a","b","c","d","e","f","g"]
let popLast : String = m.popLast()!
print(m,popLast)
//列印結果：["a", "b", "c", "d", "e", "f"]  g

poplast可以適用於空陣列和非空陣列；但是removeLast只能用於非空陣列。

*popFirst

函式主要功能：移除並返回集合的第一個元素。

2.remove

*removeLast()

函式主要功能：刪除並返回集合中最後一個元素,與popLast類似，但是removeLast函式只可用於非空陣列。

var character = ["a","b","c","d","e","f","g"]
let removeLast : String = character.removeLast()
print(m,removeLast)
//列印結果：["a", "b", "c", "d", "e", "f"]  g

*removeLast(_ k:Int)

函式主要功能：從集合的末尾移除給定數量的元素，這裡的k:指的是從陣列後往前數的個數。

var character = ["a","b","c","d","e","f","g"]
character.removeLast(4)
print(character)//列印結果：["a", "b", "c"]
 

*remove(at index: Int)

函式主要功能：刪除並返回指定下標位置的元素；index:指的是下標

var character = ["a","b","c","d","e","f","g"]
let element = character.remove(at: 4)
print(character,element)//列印結果：["a", "b", "c", "d", "f", "g"] e

*removeAll()

函式主要功能：刪除陣列中的全部元素

var phrase = "The rain in Spain stays mainly in the plain."
let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
phrase.removeAll(where: {vowels.contains($0)})
print(phrase)//print:Th rn n Spn stys mnly n th pln.
 

*removeFirst()

函式主要功能：刪除並返回陣列第一個元素，不能用於非空陣列

var character = ["a","b","c","d","e","f","g"]
let element = character.removeFirst()
print(character,element)//列印結果：["b", "c", "d", "e", "f", "g"] a

*removeFirst(_ k: Int)

函式主要功能：從集合的開始移除給定數量的元素，這裡的k:指的是從開始往後數的個數。
var character = ["a","b","c","d","e","f","g"]
character.removeFirst(3)
print(character)//列印結果：["d", "e", "f", "g"]

3.drop

*dropLast()

函式主要功能：返回一個新陣列，除了集合中的最後一個元素

var dropArray = ["a","b","c","d","e","f","g"]
let dropLast = dropArray.dropLast()
print("dropArray:",dropArray)
print("dropLast:",dropLast)
//列印結果：
//dropArray: ["a", "b", "c", "d", "e", "f", "g"]
//dropLast: ["a", "b", "c", "d", "e", "f"]

從上面的列印結果可以看出，原陣列是不變的

*dorpLast(_k: Int)

函式主要功能：返回一個新陣列，除了最後k個元素

var dropArray = ["a","b","c","d","e","f","g"]
let dropLast = dropArray.dropLast(3)
print("dropArray:",dropArray)
print("dropLast:",dropLast)
//列印結果：
//dropArray: ["a", "b", "c", "d", "e", "f", "g"]
//dropLast: ["a", "b", "c", "d"]

*dropFirst()

函式主要功能：返回一個新陣列，除了集合第一個元素之外

var dropArray = ["a","b","c","d","e","f","g"]
let dropFirst = dropArray.dropFirst()
print("dropArray:",dropArray)
print("dropLast:",dropFirst)
//列印結果：
//dropArray: ["a", "b", "c", "d", "e", "f", "g"]
//dropLast: ["b", "c", "d", "e", "f", "g"]

*dorpFirst(_k: Int)

函式主要功能：返回一個新陣列，除了前k個元素

var dropArray = ["a","b","c","d","e","f","g"]
let dropFirst = dropArray.dropFirst(3)
print("dropArray:",dropArray)
print("dropFirst:",dropFirst)
//列印結果：
//dropArray: ["a", "b", "c", "d", "e", "f", "g"]
//dropFirst: [ "d", "e", "f","g"]

4.enumerated

函式主要功能：列舉陣列中的元素以及元素下標

var m = ["a", "b", "c", "d", "e", "f", "g"]
for (num,element) in m.enumerated() {
    print(num,element)
}
//列印結果：
//0 a
//1 b
//2 c
//3 d
//4 e
//5 f
//6 g

5.reduce

函式主要功能：返回使用給定閉包組合序列元素的結果
原始碼：

//initialResult:計算的初始值，當閉包開始執行時，變為nextPartialResult返回值
//nextPartialResult: (Result, Element) :閉包，result初始值為initialResult值，之和為每次計算值；Element：陣列中的元素
reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result

eg:舉個例子，假如需要計算一個體育場，一天中每場比賽缺席的人數

let absences =  [0, 2, 0, 4, 0, 3, 1, 0]
 let midpoint = absences.count / 2

let firstHalf = absences[..<midpoint]//上午缺席
let secondHalf = absences[midpoint...]//下午缺席
//計算數缺席人數
let firstHalfSum = firstHalf.reduce(0, +)
let secondHalfSum = secondHalf.reduce(0, +)
if firstHalfSum > secondHalfSum{
    print("More absences in the first half.")
}else{
    print("More absences in the second half.")
}

上面例子中使用的是簡潔版的reduce，下面我們展開closure,看看具體實現

let productArray = [1,3,4,2]
//陣列中所有值的和,簡化；也可以換成* - %
let sumProductArray = productArray.reduce(1,+)
//展開閉包
//x：第一次執行時為初始值，之後則為上次執行時計算的結果，y:是遍歷陣列時陣列當前值
//x = 0,y = 1
//x = 1,y = 3
//x = 4,y = 4
//x = 8,y = 2
let sumProductArray = productArray.reduce(0) { x,y in
    return x + y
}

//如果想要返回平方和
let sumSquare = productArray.reduce(0) { x,y in
    return x + y * y
}

5.firstIndex

函式主要功能：獲取滿足條件的第一個元素的下標，可根據下標獲取元素
舉個例子：找到陣列中前兩個大於0的數

let absences = [0, 2, 0, 4, 0, 3, 1, 0]
if let i = absences.firstIndex(where: {$0 > 0}){
    let absenceAfterFirstDay = absences[(i+1)...]
    print(absenceAfterFirstDay.startIndex)
    if let j = absenceAfterFirstDay.firstIndex(where: { $0 > 0 }) {
        print(absenceAfterFirstDay.endIndex)
        print("The first day with absences had \(absences[i]).")    // 4
        print("The second day with absences had \(absences[j]).")
    }
}
//列印結果：
//The first day with absences had 2.
//The second day with absences had 4.

此例子展示了：集合及其子序列之間共享索引
此時需要注意的是
因為absenceAfterFirstDay是absences的子序列，所以因為absenceAfterFirstDay的index是引用的absences,所以absenceAfterFirstDay的startIndex = 2 ,endIndex = 8
startIndex:代表集合開始元素下標，子集合中代表子集合開始元素在父集合中的位置；endIndex:代表集合元素個數，子集合代表父集合的元素個數

6.stride

函式主要功能：從起始值到結束值(但不包括結束值)的序列，並按指定的數量步進

//建立一個form - to 以by間距，遞減或遞增的資料
//from > to 時，by:負值，遞減
//from < to 時。by:正值,遞增
//最後一個值小於to的值
for index in stride(from: 0, to: 12, by: 2){
    print(index)
}
//列印結果：0 2 4 6 8 10

//當from < to 時，by:正值，最後一個值小於等於through的值
//當from > to 時，by：負值，最後一個值大於等於through的值
for index in stride(from: 0, through: 13, by: 3){
    print(index)
}
//列印結果：0 3 6 9 12

7.replaceSubrange

函式主要功能：用給定集合替換指定的元素子範圍。

//range : 替換範圍
//with element ： 使用什麼元素替換
var nums = [10, 20, 30, 40, 50]
nums.replaceSubrange(1...3, with: repeatElement(1, count: 5))
print(nums)// 列印結果 "[10, 1, 1, 1, 1, 1, 50]"

8.repeatElement

函式主要功能：建立包含給定元素的指定數量的集合

let numsRepeat = repeatElement(87, count: 5)

9.suffix、suffix(_ maxLength: Int)

函式主要功能：返回包含集合的最終元素的子序列，直到給定的最大長度。
理解是從集合後面往前數給定數量的元素，形成新的子序列

var testNumber = [10,20,30,40,50,60,70,80]
print(testNumber.suffix(3))//列印結果：[40, 50, 60]

suffix(_ maxLength: Int)：

函式主要功能：返回從起始索引到集合endIndex的子序列

let suffixFromStart = [10, 20, 30, 40, 50, 60]
if let i = suffixFromStart.firstIndex(of: 40){
    print(uptoInsex.suffix(i))//is is equivalent to print(uptoInsex[i...])
}
// 列印結果： "[40, 50, 60]"

10.prefix、prefix(upTo end : Int)、prefix(through position: Int)

函式主要功能：返回包含集合的開始元素的子序列，直到給定的最大長度。
理解是從集合後面往後數至給定數量的元素，形成新的子序列

var testNumber = [10,20,30,40,50,60,70,80]
print(testNumber.prefix(3))//列印結果：[10, 20, 30]

prefix(upTo end : Int)：

函式主要功能：返回一個子序列，從集合startIndex到給定的結束索引

let uptoInsex = [10, 20, 30, 40, 50, 60]
if let i = uptoInsex.firstIndex(of: 40) {
    print(uptoInsex.prefix(upTo: i))//is equivalent to print(uptoInsex[..<i])
 }
// 列印結果： "[10, 20, 30]"

prefix(through position: Int)

函式主要功能：從集合開始到指定位置返回子序列。

let prefixThtoughPosition = [10, 20, 30, 40, 50, 60]
//Returns a subsequence,from the start of the collection through the sepecified position
if let i = prefixThtoughPosition.firstIndex(of: 40) {
    print(prefixThtoughPosition.prefix(through: i))//is equivalent to print(prefixThtoughPosition[..i])
}
//列印結果[10, 20, 30, 40]

11.split

函式主要功能：根據指定字元，將字串分解成陣列；指定字元將被刪除

//根據空格分解字串
let line = "BLANCHE:   I don't want realism. I want magic!"
print(line.split(separator: " "))
//列印結果: ["BLANCHE:", "I", "don\'t", "want", "realism.", "I", "want", "magic!"]
//split閉包展開寫法
print(line.split(whereSeparator: { (element) -> Bool in
    if element == "e" {
        return true
    }
    return false
}))
//列印結果： ["BLANCHE:   I don\'t want r", "alism. I want magic!"] if the condition 'element == "e"' change to 'element == " "',print result is same as upone

//maxSplits : 最大分解次數
//omittingEmptySubsequences : false:不忽略集合中的空字元；true:忽略集合中的空字元
print(line.split(maxSplits: 3, omittingEmptySubsequences: true, whereSeparator: { (element) -> Bool in
    if element == " " {
        return true
    }
    return false
}))
//列印結果：
//true:["BLANCHE:", "I", "don\'t", "want realism. I want magic!"]
//false:["BLANCHE:", "", "", "I don\'t want realism. I want magic!"]

12.reverse

函式主要功能：反轉集合中的元素

var characters: [Character] = ["C", "a", "f", "é"]
characters.reverse()//列印結果:["é", "f", "a", "C"]

var reverseWord = "Bela"
for char in reverseWord.reversed() {
    print(char, terminator: "")
}//列印結果:aleB

13.append(contentsOf newElements: S)

函式主要作用：拼接兩個陣列
直接拼接兩個陣列主要有兩個方法

var oldArray = [1,3,5,7]
let evenArray = [0,2,4,6,8]

oldArray.append(contentsOf: evenArray)
print(oldArray)
//列印結果：[1, 3, 5, 7, 0, 2, 4, 6, 8]

還有一個簡單方法就是兩個陣列相加

oldArray = oldArray + evenArray

列印結果是一樣的。

14.elementsEqual

函式主要功能：比較兩個陣列是否相同

evenArray.elementsEqual(oldArray)//列印結果：false

15.多維陣列

//宣告一個多維陣列
var arrayOfArrays = [[String]]()
var aA = ["AA","AB","AC"]
var bA = ["AA","BB","BC"]
var cA = ["CA","CB","CC"]

arrayOfArrays.append(aA)
arrayOfArrays.append(bA)
arrayOfArrays.append(cA)
print(arrayOfArrays)
//列印結果：[["AA", "AB", "AC"], ["BA", "BB", "BC"], ["CA", "CB", "CC"]]