iOS Swift 数组处理

获取前多少个项的数组

let arr = NSArray.init(array: arr_options).subarray(with: NSRange.init(location: 0, length: 4))

一、声明

初始化空数组
var arr_1 = []
var arr_2 = Array<Int>()
var arr_3 = [Int]()
初始化默认值的数组
var arr_4 = [1, 2, 3, 4]
var arr_5 = Array<Int>(repeating: 0, count: 5)
var arr_6 = [Int](repeating: 0, count: 5)

二、数组基本操作

添加元素
// 添到末尾
arr.append(1)
// 数组相加
arr.append(contentsOf: arr0)
arr = arr + arr0
arr += arr0
插入元素
// 在索引1（第二个位置）的位置处插入6
arr.insert(6, at: 1)
删除元素
// 删除第一个
arr.removeFirst()
// 删除最后一个
arr.removeLast()
arr.popLast()
// 删除特定位置
arr.remove(at: 1)
// 删除区间的元素
arr.removeSubrange(Range.init(NSMakeRange(0, 1))!)
// 删除所有元素
arr.removeAll()
修改元素
// 修改指定位置的元素
arr[0] = 6
// 修改数组区间的元素
arr[0...2] = [0, 1, 2]

三、数组基本方法

// 判空
arr.isEmpty()
// 数组长度
arr.count
// 获取元素
// 根据索引i
arr[i]
// 获取第一个元素
arr[0]
arr.first
// 获取最后一个元素
arr[arr.count - 1]
arr.last
// 数组最小值
arr.min()
// 数组最大值
arr.max()
// 数组区间
arr[0...1]
// 判断是否包含指定元素
arr.contains(5)
// 返回指定元素的索引
arr.index(of: 5)
遍历数组
// 遍历索引
for index in 0 ..< arr.count {
}
// through: 包含最后一个元素
// to: 不包含最后一个元素
for i in stride(from: 0, to: 4, by: 1) {
}
// 遍历元素
for ele in arr {
}
// 同时遍历索引和元素
for (index, element) in arr.enumerated() {
}
// forEach遍历
arr.forEach { (ele) in
    print(ele)
}
索引
// startIndex: 数组第一个元素的索引
// endIndex: 数组最后一个元素的索引的下一位
arr[arr.startIndex()]
// print 0
arr[arr.startIndex ..< arr.endIndex]
// print 1, 2, 3, 4, 5
// 注意endIndex不是数组最后一个元素的索引。

数组特殊方法

filter

直接过滤数组元素，返回满足条件的新数组

// $0表示arr中的元素
// 返回大于2的元素所组成的数组
let result = arr.filter { $0 > 2 }
// 传入闭包
let result = arr.filter { (ele) -> Bool in
    return ele > 2
}
map

将原来数组的元素 映射到 新的数组中，转化元素类型。

// 传入闭包
let result = arr.map { (num) -> String in
    return "\(num)Z"
}
// 每个元素 *2
let result = arr.map { $0 * 2 }
// 0~4的数组，每个元素 *2
let result = (0...4).map { $0 * 2 }
flatMap

flatMap是在map的基础上增加新的功能
空值过滤：调用flatMap生成的新数组，过滤了nil值的元素。

let result = arr.flatMap { $0 }
// swift 4.1之后，更名为compactMap。即为
let result = arr.compactMap { $0 }

强解包：flatMap自动做了解包工作，不用再去解包元素。

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

let arr: [String?] = ["123","456","789"]
let result = arr.compactMap { $0 }
// print：["123", "456", "789"]

数组压平，解嵌套数组（把二维数组变成一维数组）

let arr = [[1],[2],[3],[4]]
let result = arr.flatMap { $0 }
// print：[1, 2, 3, 4]
reduce

可以把数组变成一个元素。先指定一个初始值，然后在闭包中写一个规则。reduce就会递归调用数组的元素进行闭包运算。直到最后算出一个结果。

// 第一个参数是用来运算的初始值
// 依次用第二个参数的运算符号与数组元素进行算术运算
// 数组所有元素之和
(1...4).reduce(0, +)
// print：10
// 数组所有元素之差
(1...4).reduce(0, -)
// print：-10
// 数组所有元素之积
(1...4).reduce(1, *)
// print：24
// 数组所有元素之商
(1...4).reduce(24, /)
// print：1

// 数组所以元素异或：相同为0，不同为1
[1,1,1,1].reduce(0, ^)
// print：0
[1,1,1,0].reduce(0, ^)
// print：1
将数组元素连成字符串，并添加指定内容。闭包和简写形式：
// 闭包形式
let arr = [1,1,1,0]
let result = arr.reduce("hello") { (a1, a2) -> String in
    return "\(a1)" + "\(a2)"
}
// print: hello1110
// 简写形式
let result = arr.reduce("hello") { "\($0)" + "\($1)" }
// print: hello1110
prefix，suffix
var arr = [1,2,3,4,5]
// prefix: 从头开始获取
// upto: [0, 3) 不包含第三个元素的索引：0，1，2
let result = arr.prefix(upTo: 3)
// 结果：[1,2,3]

// suffix: 截取至尾部
// 从第三个元素到末尾
let result = arr.suffix(from: 3)
// 结果：[4,5]
dropFirst()，dropLast()

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

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

// 从尾部开始删除三个元素
let result = arr.dropLast(3)
// 结果：[1,2]
验证字符串中是否含有某个单词
let words = ["Strengthen", "Swift", "iOS"]
let sentence = "My name is Strengthen"

// filter
let result = !words.filter({sentence.contains($0)}).isEmpty
// 结果是true，result为["Strengthen"]

// contains
let result = words.contains(where: sentence.contains)

// 拆分
let result = sentence.split(separator: " ").lazy.map(String.init).contains(where: Set(words).contains)
埃拉托色尼选筛法（求小于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]
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
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]
contains

contains的一个好处就是只要遇到满足条件的元素，函数的执行就终止了。
基于这个contains，还可以给Array添加一个新的方法，用来判断Array中所有的元素是否满足特定的条件。

var arr = [1,2,3,4,5]
//判断是否包含偶数
let result = arr.contains{ $0 % 2 == 0}
print(result)
//Print true
交换数组中元素的值
let str = "strengthen"

//prefix
print(str.prefix(5)) // "stren"
//suffix
print(str.suffix(5)) // "gthen"

//dropFirst
print(str.dropFirst()) // "trengthen"
//dropLast
print(str.dropLast()) // "strengthe"

swap()方法被废弃，建议使用tuple（元组）特性来实现值交换

var a = 1
var b = 2
(b, a) = (a, b)
print(a, b)

tuple方式还可以实现多个变量值一起进行交换：

var a = 1
var b = 2
var c = 3
(b, a, c) = (a, b, c)
print(a, b, c)

数组增加了个swapAt方法可以实现数组中两个元素的位置交换。

var fruits = ["apple", "pear", "grape", "banana"]
fruits.swapAt(1, 2)
print(fruits)

forEach
调用相同的顺序作为序列中的每个元件上给定的for-in循环
以下两个例子输出相同的结果：

let numberWords = ["one", "two", "three"]
for word in numberWords {
    print(word)
}
// Prints "one"
// Prints "two"
// Prints "three"

numberWords.forEach { word in
    print(word)
}
// Same as above

不能使用break，continue语句退出当前的body闭包调用或跳过后续调用
使用闭包中的return语句body将仅从当前调用退出body，而不是从任何外部作用域退出，并且不会跳过后续调用
遍历同类型的泛型集合

let arr = [1,2,3,4,5,6,7,8,9]
//for循环
for i in arr
{
    print(i)
}
/*
1
2
3
4
5
6
7
8
9
*/

//forEach
arr.forEach
{
    (element) in
    print(element)
}
/*
1
2
3
4
5
6
7
8
9
*/

遍历不同类型的泛型集合

let array = [1,2,3,4,5,"6","7","8","9"] as [Any]
//for循环
for element in array
{
    //判断类型
    if element is Int
    {
        print(element)
    }
}
/*
1
2
3
4
5
*/

//forEach
array.forEach
{
    (element) in
    //判断类型
    if element is String
    {
        print(element)
    }
}
/*
6
7
8
9
*/

is：用来判断某一个对象是否是某一特定的类，返回一个bool类型的值

sorted排序
sorted只返回一个数组的有序版本，不修改原数组
sort无返回值，只会修改原数组

var arr = [Int]()

// 升序
arr = arr.sorted(by: <)
// 降序
arr = arr.sorted(by: >)

// 自定义升降序
func sortArray(num1: Int, num2: Int) {
    return num1 < num2
}

// 数组调用方法
arr.sort(by: sortArray)
arr.sort(by: { (num1: Int, num2: Int) -> Bool in return num1 < num2 })

// 闭包可以不指定类型
arr.sort(by: { (num1, num2) -> Bool in return num1 < num2 })
// 可以省略参数名，直接根据闭包来引用参数
arr.sort(by: { return $0 < $1 })
// 如果闭包只含一行语句，可以省略return关键字
arr.sort(by: {$0 < $1})
// 如果闭包是最后一个参数，可以将闭包直接放在小括号外面的大括号里，换行也是可选的。
arr.sort() { $0 < $1 }
// 甚至可以省略闭包，得最简形式
arr.sorted(by: <)

sorted()无参数时默认为升序
要以特定顺序迭代集合的值，应该使用sorted()方法，该方法将集合的元素作为使用<排序的数组返回

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

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

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

NSArray是一个类，是引用类型。有两点与Array不同

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

Array是一个结构体，是值类型
Array是按照值语义实现的。当复制一个Array对象时，会拷贝整个Array的内容。

参考文献：
Swift数组Array最强解析

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 159,716评论 4赞 364
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,558评论 1赞 294
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 109,431评论 0赞 244
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 44,127评论 0赞 209
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,511评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,692评论 1赞 222
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,915评论 2赞 313
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,664评论 0赞 202
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,412评论 1赞 246
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,616评论 2赞 245
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,105评论 1赞 260
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,424评论 2赞 254
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,098评论 3赞 238
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,096评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,869评论 0赞 197
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,748评论 2赞 276
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,641评论 2赞 271