Swift学习-Array

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"]]

Swift学习-Array

原文：https://www.cnblogs.com/PotatoToEgg/p/14922300.html