Swift Array 合集

数组元素倒序

使用 reversed()

交换数组中两个元素位置

var originArrayOne = [2,3,4]
print("originArrayOne排序前:\(originArrayOne)")
swap(&originArrayOne[0], &originArrayOne[2])
print("originArrayOne排序后:\(originArrayOne)\n")

或者

var originArrayTwo = [2,3,4]
print("originArrayTwo排序前:\(originArrayTwo)")
(originArrayTwo[0],originArrayTwo[2]) = (originArrayTwo[2],originArrayTwo[0])
print("originArrayTwo排序后:\(originArrayTwo)\n")

数组去交集

How to find the difference between two arrays

extension Array where Element: Hashable {
    func difference(from other: [Element]) -> [Element] {
        let thisSet = Set(self)
        let otherSet = Set(other)
        return Array(thisSet.symmetricDifference(otherSet))
    }
}

使用：

let names1 = ["John", "Paul", "Ringo"]
let names2 = ["Ringo", "Paul", "George"]
let difference = names1.difference(from: names2)

数组去重

Swift之数组去重(去除重复元素)

如果数组内只含有基础类型的数据时，可以写两个for循环遍历，用下标取值做对比；当然也可以用集合 Set（Swift），比较方便快捷。

但是如果需要对 model 数组进行去重，则用不了 Set。

import UIKit

extension Array {
    
    // 去重
    func filterDuplicates<E: Equatable>(_ filter: (Element) -> E) -> [Element] {
        var result = [Element]()
        for value in self {
            let key = filter(value)
            if !result.map({filter($0)}).contains(key) {
                result.append(value)
            }
        }
        return result
    }
}

// 基础类型去重
let arrays = ["1", "2", "2", "3", "4", "4"]
let filterArrays = arrays.filterDuplicates({$0})
print(filterArrays)

// model类的去重
let modelArrays = [Model("1"), Model("1"), Model("2"), Model("3")]
let filterModels = modelArrays.filterDuplicates({$0.name})
print(filterModels)

Swift数组去重

let arr = ["apple", "strawberry", "pear", "apple", "orange", "orange", "strawberry"]
let results = arr.enumerated().filter { (index,value) -> Bool in
		return arr.firstIndex(of: value) == index
}.map {
    $0.element
}

or

let arr = ["apple", "strawberry", "pear", "apple", "orange", "orange", "strawberry"]
arr.removeDuplicate()
// Array 扩展
public extension Array where Element: Equatable {
    
    /// 去除数组重复元素
    /// - Returns: 去除数组重复元素后的数组
    func removeDuplicate() -> Array {
        return self.enumerated().filter { (index,value) -> Bool in
            return self.firstIndex(of: value) == index
        }.map { (_, value) in
            value
        }
    }
}

Set 操作

• Swift5 集合（Set）操作
• 判断俩数组是否相等[并集、交集、差集]

随机取元素

originalArray = [1, 2, 3, 4]

// 打乱，取3个元素
newArray = originalArray.shuffled().suffix(3)

// 数组数据类型提供了randomElement() ，该函数返回一个Element? 
let item = originalArray.randomElement()

排序

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

基本

// 降序
let a = ["2","1","3"] 
let i = a.sorted { 
      (s1, s2) -> Bool in 
      return s1 > s2  
}
print("\(i)")//打印结果：["3","2","1"]

// 升序
let a = ["2","1","3"] 
let i = a.sorted { 
    (s1, s2) -> Bool in 
    return s1 < s2
} 
print("\(i)")//打印结果：["1","2","3"]

// 简化
let a = ["2","1","3"] 
let i = a.sorted {
    $0 < $1
} 
print("\(i)")//打印结果：["1","2","3"]


// 最简
let a = ["2","1","3"]
let i = a.sorted(<) 
print("\(i)")//打印结果：["1","2","3"]

高阶

自定义升序排序方法

func sortArray(num1: Int, num2: Int) -> Bool {
	return num1 < num2
}

arr.sort(by: sortArray)

或者

arr.sort(by: { (num1: Int, num2: Int) -> Bool in return num1 < num2 })

// 闭包可以不指定参数类型，编译器会进行判断
arr.sort(by: {(num1, num2) in return num1 < num2})

// 可以省略参数名，直接根据闭包来引用参数
arr.sort(by: { return $0 < $1 })

// 如果闭包只包含一行语句，可以省略 return 关键字
arr.sort(by: { $0 < $1 })
arr.sort(){ $0 < $1 }
arr.sort(by: <)