[Swift]数组(Array)最强解析

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

➤微信公众号：MindDraft
➤博主域名：https://www.zengqiang.org
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10297316.htm
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

 

一、声明数组

1.1 初始化空数组

var arr1 = []
var arr2 = Array<Int>()
var arr3 = [Int]()

1.2 初始化具有默认值的数组

var arr4 = [1,2,3,4,5]
var arr5 = Array<Int>(repeating: 0, count: 5)
var arr6 = [Int](repeating: 0, count: 5)

二、数组基本操作 

var arr = [1,2,3,4,5]

2.1 添加元素

//方法1：添加元素到末尾
arr.append(1)
//方法2：数组相加，数组类型必须一致
arr += [6,7,8,9]
arr = arr + [6,7,8,9]

2.2 插入元素

//在索引1(第二个位置)插入元素6
arr.insert(6,at:1)

2.3 删除元素

• removeFirst、removeLast()，需要代码逻辑判断确保数组中非空，否则会引发运行时错误。
• popLast()，如果数组为空，则返回nil。注意无popFirst()方法。

//删除第一个元素
arr.removeFirst()

//删除最后一个元素
//保证数组非空
arr.removeLast()
//空数组时返回nil
arr.popLast()

//根据元素索引删除元素
arr.remove(at: 1)

//删除数组区间的元素
arr.removeSubrange(Range.init(NSMakeRange(1, 2))!)

//删除所有元素
arr.removeAll()

2.4 修改元素

//修改指定索引元素
arr[0] = 6
//修改数组区间的元素
arr[1...3] = [1,2,3]

三、数组基本方法 

var arr = [1,2,3,4,5]

3.1 判空

arr.isEmpty

3.2 数组长度

arr.count

3.3 获取元素

//根据索引i：
arr[i]
//获取第一个元素：
arr.first 
arr[0]
//获取最后一个元素：
arr.last 
arr[arr.count-1]

3.4 数组最值

//数组最小值
arr.min()
//数组最大值
arr.max()

3.5 数组区间

arr[0...1]

3.6 判断包含指定元素

arr.contains(5)

3.7 返回指定元素索引

//返回值为可选型Optional Type（可选类型）
arr.index(of: 5)
//Optional(4)

3.8 遍历数组

//方法一：遍历索引
for index in 0..<arr.count{
    arr[index]
}

//through：包含最后一个元素
//to：不包含最后一个元素
for i in stride(from:0,through:4,by:1)
{
    print(arr[i])
}

//方法二：遍历元素
for number in arr{
    print(number)
}

//方法三：同时遍历索引和元素
for (index, number) in arr.enumerated(){
    //遍历数组索引和元素
    print("\(index+1): \(vowel)")
}

//方法四：forEach遍历
arr.forEach
{
    (element) in
    print(element)
}

请点击链接：[Swift]forEach详解

3.9 startIndex、endIndex

startIndex：数组第一个元素的索引。

endIndex：数组最后一个元素的索引的下一位。 

var arr = [1,2,3,4,5]

//startIndex是数组第一个元素的索引
print(arr[arr.startIndex])
//Print 1

print(arr[arr.startIndex..<arr.endIndex])
//Print [1, 2, 3, 4, 5]

//注意endIndex不是数组最后一个元素的索引
print(arr[..<arr.endIndex])
//Print [1, 2, 3, 4, 5]

 四、数组特殊方法 

4.1 filter

(1)直接过滤数组元素，返回满足符合条件的新数组。 

var arr = [1,2,3,4,5]
//$0表示arr中的元素
//返回大于2的元素组成的数组
let filterArr = arr.filter { $0 > 2 }

 (2)传入一个闭包函数作为参数，作为判断条件，返回满足符合条件的新数组。 

var arr = ["123Z","456Z","789"]
let filterArr = arr.filter { (str) -> Bool in
           return str.contains("Z")}
print(filterArr)
//Print ["123Z", "456Z"]

4.2 map

将原来数组中的元素映射到新的数组中，映射数组元素，转化元素类型。
map函数以一个闭包函数作为参数，返回一个新的数组，编译器会自动根据调用它的数组类型自动推断出返回数组的类型。

var arr = [1,2,3,4,5]
//映射成字符串类型
let mapArr1 = arr.map { (num) -> String in
    return "\(num)" + "Z"
}
print(mapArr1)
//Print ["1Z", "2Z", "3Z", "4Z", "5Z"]


//将数组中每个元素的值乘以3
let mapArr2 = (1...5).map{$0*3}
print(mapArr2)
//Print [3, 6, 9, 12, 15]

4.3 flatMap

flatMap方法是在map方法的基础上增加新的功能。

(1) 空值过滤：调用flatMap生成的新数组过滤掉了nil值的元素，得到的新数组里面全部都是非nil得元素。

String类型

let arr = ["1", "2", "3", "4", nil]
let newArr = arr.flatMap { $0 }
print(newArr)
//Print ["1", "2", "3", "4"]

Int类型

let arr = [1, 2, 3, 4, nil]
let newArr = arr.flatMap { $0 }
print(newArr)
//Print [1, 2, 3, 4]

(2) 强解包：flatMap自动帮我们做了解包的工作，不用去解包元素。以map方法进行对比。

//以map方法进行对比
let arr1:[String?] = ["123", "456", "789"]
let newArr1 = arr1.map { $0 }
print(newArr1)
//Print [Optional("123"), Optional("456"), Optional("789")]

//flatMap
let arr2:[String?] = ["123", "456", "789"]
let newArr2 = arr2.flatMap { $0 }
print(newArr2)
//Print ["123", "456", "789"]

(3) 数组压平解嵌套数组：指是把一个二维数组里面的元素（数组）展开成一维数组。

检查数组中有没有嵌套数组，把嵌套的数据结构再重组成一个数组。

var arr = [[1], [2], [3], [4], [5]]
let flatMapArr = arr.flatMap{ $0 }
//压平解嵌套数组
print(flatMapArr)
// Print [1, 2, 3, 4, 5]

请点击链接：[Swift]多维数组的表示和存储：N维数组映射到一维数组(一一对应)！

4.4 compactMap

过滤数组中出现的nil和可选类型。 

可以把一个集合中的空值去除，并且返回一个去除nil值得数组

let numbers = [1, 2,nil, 5]

//compactMap
let compactMapResult = numbers.compactMap { (number) -> Int? in
    return number
}
print(compactMapResult)
//Print [1, 2, 5]

//map
let mapResult = numbers.map { (number) -> Int? in
    return number
}
print(mapResult)
//Print [Optional(1), Optional(2), nil, Optional(5)]

 4.5 reduce

可以把数组变成一个元素，首先需要指定一个初始值，然后在闭包中写一个reduce的规则，接着reduce方法会开始递归的对数组中的元素进行闭包运算，直到算出最后一个结果。

注意还可以用于其他符号，不只是四则运算符。

//第一个参数为用来运算的初始值。
//依次用第二个参数的运算符号与数组元素进行算术运算。

//数组所有元素之和
print((1...5).reduce(0, +))
//Print 15

//数组所有元素之差
print((1...5).reduce(0, -))
//Print -15

//数组所有元素之积
print((1...5).reduce(1, *))
//Print 120

//数组所有元素之商
print((1...5).reduce(120, /))
//Print 1

//数组所有元素异或:相同为0，不同为1
print([1,1].reduce(0, ^))
//Print 0
print([1,1,1].reduce(0, ^))
//Print 1

将数组元素连接成字符串并添加指定内容，闭包和简写形式：

var arr = [1,2,3,4,5]
//闭包形式
let newArr1 = arr.reduce("strengthen") { (a1, a2) -> String in
          return "\(a1)" + "\(a2)"}
print(newArr1)
//Print strengthen12345

//简写形式
let newArr2 = arr.reduce("Z"){ "\($0)" + "\($1)" }
print(newArr2)
//Print Z12345

4.6 prefix、suffix

获取数组从头或从尾开始的一段片段。

var arr = [1,2,3,4,5]
//prefix：从头部开始截取
//upTo：[0,3),不包含第三个元素的索引:0,1,2
let prefixArr = arr.prefix(upTo: 3)
print(prefixArr)
//Print [1, 2, 3]

//suffix：截取至尾部
//从第三个元素到末尾，包含第三个元素的索引:3，4
let suffixArr = arr.suffix(from: 3)
print(suffixArr)
//Print [4, 5]

4.7 dropFirst()、dropLast()

 与prefix、suffix互补的方法，获得删除从头部或尾部开始的区间元素后的数组。

var arr = [1,2,3,4,5]
//从头部开始删除三个元素
let dropFirstArr = arr.dropFirst(3)
print(dropFirstArr)
//Print [4, 5]

//从尾部开始删除三个元素
let dropLastArr = arr.dropLast(3)
print(dropLastArr)
//Print [1, 2]

4.8 验证字符串中是否包含某个单词

let words = ["Strengthen","Swift","iOS"]
let sentence = "My name is Strengthen"

//方法1:filter
let result1 = !words.filter({sentence.contains($0)}).isEmpty
print(result1)
//Print true

//方法2:contains
let result2 = words.contains(where: sentence.contains)
print(result2)
//Print true
        
//方法3:拆分
let result3 = sentence.characters
        .split(separator: " ")
        .lazy
        .map(String.init)
        .contains(where: Set(words).contains)
print(result3)
//Print true

 4.9 埃拉托色尼选筛法（求小于N的所有质数）

let number = 100
var primes = Set(2...number)
(2...Int(sqrt(Double(number)))).forEach {
   let _ = primes.subtract(stride(from: 2*$0, through: number, by: $0))
}
print(primes.sorted())
//Print [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

4.10 elementsEqual

比较数组相等或以特定元素开始。对这类操作，需要提供两个内容，一个是要比较的数组，另一个则是比较的规则

var arr = [1,2,3]
//比较另一个数组的各元素是否时原数组各元素的两倍
let result1 = arr.elementsEqual([2,4,6], by: { $0*2 == $1 })
print(result1)
//Print true

//比较从头部开始的元素区间是否相同
let result2 = arr.starts(with: [1,2], by: { $0 == $1 })
print(result2)
//Print true

 4.11 partition

partition(by:)则会先对传递给它的数组进行重排，然后根据指定的条件在重排的结果中返回一个分界点位置。

这个分界点分开的两部分中：前半部分的元素都不满足指定条件；后半部分都满足指定条件。

这样就可以使用range operator来访问者两个区间形成的Array对象。

var arr = [1,2,3,4,5]

//条件：大于3
let privot1 = arr.partition(by: { $0 > 3 })
print(privot1)
//Print 3

//前半部分是不符合条件的元素
print(arr[0..<privot1]) 
//Print [1, 2, 3]

//后半部分是符合条件的元素
print(arr[privot1..<arr.endIndex])
//Print [4, 5]


//条件：小于3
let privot2 = arr.partition(by: { $0 < 3 })
print(privot2)
//Print 3

//前半部分是不符合的元素
print(arr[0..<privot2]) 
//Print [5, 4, 3]

//后半部分是符合条件的元素
print(arr[privot2..<arr.endIndex])
//Print [[2, 1]

4.12 contains

contains的一个好处就是只要遇到满足条件的元素，函数的执行就终止了。

基于这个contains，还可以给Array添加一个新的方法，用来判断Array中所有的元素是否满足特定的条件。

var arr = [1,2,3,4,5]
//判断是否包含偶数
let result = arr.contains{ $0 % 2 == 0}
print(result)
//Print true

4.13 交换数组中元素的值

请点击链接：[Swift]Array数组的swapAt函数

4.14 forEach：

请点击链接：[Swift]forEach详解

注意，在forEach闭包中，return不会中断整个遍历。

4.15 sorted：排序

请点击链接：[Swift]数组排序：sort和sorted 

4.16.字符串直接转换成字符数组或字符串数组

let str:String = "strengthen"
//方法1:转换为字符数组
var arr1:[Character] = Array(str)
print(arr1)
//Print ["s", "t", "r", "e", "n", "g", "t", "h", "e", "n"]

//方法2：转换为字符串数组
var arr2:[String] = str.map{ String($0) }
print(arr2)
//Print ["s", "t", "r", "e", "n", "g", "t", "h", "e", "n"]

五、NSArray与Array

(1)Array是一个结构体，是值类型。

在Swift中，Array是按照值语义实现的，当我们复制一个Array对象时，会拷贝整个Array的内容。

(2)NSArray是一个类，是引用类型。

在Foundation中，数组这个类型有两点和Swift的Array是不同的：

• 数组是否可以被修改时通过NSArray和NSMutableArray这两个类型来决定的
• NSArray和NSMutableArray都是类对象，复制他们执行的是引用语义 

var arr: [NSObject] = [1 as NSObject,"swift" as NSObject]