当前位置： 代码迷 >> 综合 >> Day-08:数组
  详细解决方案

Day-08:数组

热度：24   发布时间：2023-09-29 19:08:46.0
  • 字面量创建数组
  1. 可以使用数组字面量来初始化一个数组，它是一种以数组集合来写一个或者多个值的简写方式。数组字面量写做一系列的值，用逗号隔开，用方括号括起来。
  2. 创建空数组的时候必须携带类型信息。
  3. 如果内容已经提供了类型信息。比如说作为函数的实际参数或者已经分类了的变量或常量，你可以通过空数组字面量来创建一个数组。
  • 使用初始化器创建数组
  1. [类型]（）
  2. Array<类型>（）
  • 使用Array(repeateding:count:)创建数组
  • 数组遍历
  • for - in 遍历
  • forEach遍历
  1. 无法使用break或continue跳出或者跳出循环。
  2. 使用return只能退出当前一次循环的执行体。
  • 同时得到索引和值 enumerated()遍历
  • 使用lterator（迭代器）遍历
  • 索引
  1. starIndex 返回第一个元素的位置，对于数组来说，永远都是0。
  2. endIndex 返回最后一个元素索引+1的位置，对于数组来说，等同于count。
  3. 如果数组为空，startIndex等于endIndex。
  • Indices 获取数组的索引区间。
  • 【代码演示】 
    //1、字面量创建
var arry:[Int] = [1,2,3]
print(arry)
arry = []
arry.append(2)
print(arry)//2、Array(repeateding:count:)
let fiveZs = Array(repeating: "z", count: 5)
print(fiveZs)//结果：[z、z、z、z、z]
//3、其他
let numbers = [Int](0...7)
print(numbers)//结果：[0、1、2、3、4、5、6、7]
let persons = ["zhangsan":27,"lisi":25,"wangwu":29]
let names = [String](persons.keys)
print(names)//结果：["wangwu", "zhangsan", "lisi"]
///数组遍历
//1、for-in
let nickName:[String] = ["小明","小杰","小张"]for item in nickName {print(item)//结果：小明 小杰 小张
}//2、forEach
let agesArray = [Int](0...7)
agesArray.forEach { (age) inprint(age * 10)//结果：0 10 20 30 40 50 60 70
}//3、enmerated()let appleIndex = [Int](2...7)
for (index,num) in appleIndex.enumerated() {print("index is \(index), appleIndex is \(num)")
}/** 结果index is 0, appleIndex is 2index is 1, appleIndex is 3index is 2, appleIndex is 4index is 3, appleIndex is 5index is 4, appleIndex is 6index is 5, appleIndex is 7*///4、Iterator
let computers = [Int](2...7)var computersIterator = computers.makeIterator()
while let num = computersIterator.next() {print(num)//结果：2、3、4、5、6、7
}//5、indices
let indicesTest = [Int](2...7)for i in indicesTest.indices{print(indicesTest[i])//结果：2、3、4、5、6、7
}
  • 判断是否包含指定元素。
  1. Contains(_:)判断是否包含给定元素。
  2. Contains(where:)判断数组是否包含符合给定条件的元素。
  • 判断所有元素符合某个条件。
  1. allSatisfy(_:)判断数组的每一个元素都符合给定的条件。
  • 查找元素
  1. first返回数组第一个元素（optional），如果数组为空，返回nil。
  2. last返回数组最后一个元素（optional），如果数组为空，返回nil。
  3. First（where：）返回数组第一个符合给定调剂的元素（optional）。
  4. Last（where：）返回数组最后一个符合给定条件的元素（optional）。
  • 查找索引。
  1. firstIndex(of:)返回给定的元素在数组中出现的第一个位置（optional）。
  2. lastIndex(of:)返回给定元素在数组中出现的最后一个位置（optional）。
  3. firstIndex(where:)返回符合条件第一个位置（optional）。
  4. lastIndex(where:)返回符合条件最后一个位置（optional）。
  • 查找最大最小元素
  1. Min()返回数组最小的元素。
  2. Max()返回数组中最大的元素。
  3. Mind(by:)利用给定的方式比较元素并返回数组中的最小元素。
  4. Max(by:)利用给定的方式比较元素并返回数组中的最发元素。
  • 【代码演示】??????? 
    //6、contains() contains(where:)
let containsArray = [10,20,30,45,98,101,30,4]
print(containsArray.contains(30))//结果：true
print(containsArray.contains(where :{$0 < 3 }))//结果：false//7、first last first（where：）
let intArray = [10,20,30,45,98,101,30,4]
print(intArray.first)//结果：Optional(10)
print(intArray.last)//结果：Optional(4)
print(intArray.first(where:{$0 > 30 }))//结果：Optional(45)
print(intArray.last(where:{$0 > 30}))//结果：Optional(101)//8、firstIndex(of:) 、lasttIndex(of:)、firstIndex(where:) 、lastIndex(where:)print(intArray.firstIndex(of: 9))//结果：nil
print(intArray.lastIndex(of: 30))//结果：Optional(6)
print(intArray.firstIndex(where: {$0 > 30}))//结果：Optional(3)
print(intArray.lastIndex(where: {$0 > 30}))//结果：Optional(5)//9、min() max()print(intArray.min())//结果：Optional(4)
print(intArray.max())//结果：Optional(101)let errors = [(12,"error12"),(23,"error23"),(34,"error35"),(12,"error12")]print(errors.min(by: {(a,b) -> Bool ina.1 < b.1
}))//结果：Optional((12, "error12"))
  • 在末尾添加元素。
  1. Append(_:)在末尾添加一个元素。
  2. Append(contentsOf:)在末尾添加多个元素。
  • 在任意位置插入。
  1. Insert（_:at:）在指定位置插入一个元素。
  2. Insert（contensOf:at:）在指定位置插入多个元素。
  • 字符串也是collection
  1. 字符串也是collection，element是character类型。
  • 移除单个元素
  1. Remove（at:）移除并返回指定位置的一个元素。
  2. removeFirst（）移除并返回数组的第一个元素。
  3. popFirst(（）移除并返回数组的第一个元素（optional）,数组为空返回nil。
  • 移除多个元素
  1. removeFirst(:)移除数组前面多个元素。
  2. removeLast(:)移除数组后面多个元素。
  3. removeSubrange(_:)移除数组中给定范围的元素。
  4. removeAll（）移除数组所有元素。
  5. removeAll(keepingCapacity)移除数组所有元素，保留数组容量。
  • 【代码演示】 
    //10、在末尾添加元素
var foodsArray = [Int](2...7)
foodsArray.append(100)
print(foodsArray)//结果：[2, 3, 4, 5, 6, 7, 100]
foodsArray.append(contentsOf: 100...105)
print(foodsArray)//结果：[2, 3, 4, 5, 6, 7, 100, 100, 101, 102, 103, 104, 105]//11、在任意位置插入元素
var inserArray = [Int](2...7)
inserArray.insert(-1, at: 0)
print(inserArray)//结果：[-1, 2, 3, 4, 5, 6, 7]
inserArray.insert(contentsOf: 8...10, at: 0)
print(inserArray)//结果：[8, 9, 10, -1, 2, 3, 4, 5, 6, 7]
//12、字符串也是collection
var chars:[Character] = ["a","b","c"]
chars.insert(contentsOf: "hellow", at: 0)
print(chars)//结果：["h", "e", "l", "l", "o", "w", "a", "b", "c"]
//13、移除单个数组
var charNumArray:[Character] = ["a","b","c","d"]
let removedChar = charNumArray.remove(at: 1)
print(removedChar)//结果：b
print(charNumArray)//结果：["a", "c", "d"]
let remmovedNewChar = charNumArray.removeFirst()
print(remmovedNewChar)//结果：b
print(charNumArray)//结果：["c", "d"]
//14、移除多个数组
var charSubNumArray:[Character] = ["a","b","c","d","e"]
charSubNumArray.removeFirst(2)
print(charSubNumArray)//结果：["c", "d","e"]
charSubNumArray.removeLast(2)
print(charSubNumArray)//结果：["c"]var charNewSubNumArray:[Character] = ["a","b","c","d","e"]
charNewSubNumArray.removeSubrange(1...2)
print(charNewSubNumArray)//结果：["a", "d", "e"]
charNewSubNumArray.removeAll(keepingCapacity: true)print(charNewSubNumArray)//结果：[]
print(charNewSubNumArray.capacity)//结果：5
  • 数组切片ArraySlice 
  1. ArraySlice 是数组或者其他ArraySlice 的一段连续切片，和原数组共享内存。
  2. 当要改变ArraySlice 的时候，ArraySlice 会copy出来，形成单独的内存。
  3. ArraySlice拥有和array基本完全类似的方法。
  • 通过Drop得到ArraySlice 
  1. dropFirst(:) 移除原数组前面指定个数的元素得到一个ArraySlice。
  2. dropLast(:) 移除原数组后面指定个数的元素得到一个ArraySlice。
  3. Drop(:) 移除原数组符合指定条件的元素得到一个ArraySlice。
  • 通过prefix得到ArraySlice 
  1. Prefix（）获取数组前面指定个数的元素组成的ArraySlice 。
  2. Prefix（upTo:）获取数组到指定位置（不包含指定位置）前面的元素组成的ArraySlice 。
  3. Prefix(through:)获取数组到指定位置（包含指定位置）前面的元素组成的ArraySlice 。
  4. Prefix(while:)获取数组前面符合条件的元素（到第一个不符合条件的元素截止）组成ArraySlice。
  • 通过suffix得到ArraySlice 
  1. Suffix()获取数组后面指定个数的元组组成的ArraySlice。
  2. 通过range得到ArraySlice 
  3. 可以通过对数组下标指定range获取ArraySlice，可以使用闭区间、半开半闭区间、单侧区间、甚至可以只使用...来获取整个数组组成的ArraySlice。
  • ArraySlice转为数组
  1. ArraySlice无法直接赋值给一个array的常量或变量，需要使用Array(slice)。
  • ArraySlice和原array相互独立
  1. ArraySlice和原array是相互独立的，它们添加删除不会影响对方。
  • 【代码演示】

//15、通过Drop得到ArraySlice
let dropArrays = [5,2,10,1,0,100,46,99]
dropArrays.dropFirst()//结果：[2,10,1,0,100,46,99]
dropArrays.dropFirst(3)//结果：[0,100,46,99]
dropArrays.dropLast()//结果：[0,100,46]
dropArrays.dropLast(1)//结果：[0,100,46]
print("\(dropArrays.drop{ $0 < 60 })")//结果：[100, 46, 99]
print(dropArrays.dropLast(1))
//16、通过prefix得到ArraySlice
let prefixArrays = [5,2,10,1,0,100,46,99]
prefixArrays.prefix(4)//结果：[5, 2, 10, 1]
prefixArrays.prefix(upTo: 4)//结果：[5, 2, 10, 1]
prefixArrays.prefix(through: 4)//结果：[5, 2, 10, 1, 0]
prefixArrays.prefix(while: {$0 < 10 })//结果：[5, 2]
//17、通过suffix得到ArraySlice
let suffixArrays = [5,2,10,1,0,100,46,99]
suffixArrays.suffix(3)//结果：[100, 46, 99]
suffixArrays.suffix(from: 6)//结果：[46, 99]
//18、通过range得到ArraySlice
let rangeArrays = [5,2,10,1,0,100,46,99]
rangeArrays[3...5]//结果：[1、0,100]
rangeArrays[3..<5]//结果：[1、0]
rangeArrays[...2]//结果：[5、2、10]
rangeArrays[..<2]//结果：[5、2]
rangeArrays[6...]//结果：[46、99]
rangeArrays[...]//结果：[5,2,10,1,0,100,46,99]
//19、ArraySlice转为数组
var sliceArrays = [5,2,10,1,0,100,46,99]
let slice = sliceArrays[3...5]
sliceArrays = Array(slice)//结果：[1、0,100]//20、ArraySlice和原array相互独立
var arr = [10,46,99]
var sli = arr.dropLast()//[10, 46, 99]
arr.append(333)//[10, 46, 99, 333]
print(sli)//[10, 46]
sli.append(555)//[10, 46, 555]
print(arr)//[10, 46, 99, 333]
  • 数组元素的随机化。
  1. Shuffle()在原数组上将数组元素打乱，只能作用在数组变量上。
  2. Shuffled()返回原素组的随机化数组，可以作用在数组变量和常量上。
  • 数组的逆序。
  1. Reverse（）在元数组上将数组逆序，只能作用在数组变量上。
  2. Reversed（）返回原素组的逆序集合表示，可以作用在数组变量和常量上，该方法不会分配内存空间。
  • 数组分组
  1. partition将数组以某个条件分组，数组前半部分都是不符合条件的元素，数组后半部分都是都是符合条件的元素。
  • 【代码演示】 
    //21、数组元素的随机化
var shuffleVArray = [Int](1...8)
shuffleVArray.shuffle()//结果：[2, 4, 8, 3, 1, 7, 6, 5]
print(shuffleVArray)//结果：[2, 4, 8, 3, 1, 7, 6, 5]
let shuffleLArray = [Int](1...8)
shuffleVArray.shuffled()//结果：[4, 5, 3, 8, 1, 7, 6, 2]
print(shuffleVArray)//结果：[2, 4, 8, 3, 1, 7, 6, 5]
shuffleLArray.shuffled()//结果：[4, 2, 7, 3, 1, 6, 5, 8]
print(shuffleLArray)//结果：[1, 2, 3, 4, 5, 6, 7, 8]
//22、数组逆序
var reverseVArray = [Int](1...8)
reverseVArray.reverse()//结果：[8, 7, 6, 5, 4, 3, 2, 1]
print(reverseVArray)//结果：[8, 7, 6, 5, 4, 3, 2, 1]
let reverseLArray = [Int](1...8)
reverseLArray.reversed()//结果：ReversedCollection<Array<Int>>
print(reverseLArray)//结果："[1, 2, 3, 4, 5, 6, 7, 8]
//23、数组的分组 partitionvar pArray = [10,20,45,30,98,101,30,4]
let index = pArray.partition { (element) -> Boolinelement > 30
}
print(pArray)
let partition1 = pArray[..<index]//结果：[10, 20, 4, 30, 30]
let partition2 = pArray[index...]//结果：[101, 98, 45]
print(partition1)//结果：[10, 20, 4, 30, 30]
print(partition2)//结果：[101, 98, 45]
//24、数组排序var sortVArray = [10,20,45,30,98,101,30,4]
sortVArray.sort()//结果：[4, 10, 20, 30, 30, 45, 98, 101]
print(sortVArray)//结果：[4, 10, 20, 30, 30, 45, 98, 101]
let sortLArray = [10,20,45,30,98,101,30,4]
sortLArray.sorted()//结果：[4, 10, 20, 30, 30, 45, 98, 101]
print(sortLArray)//结果： [10,20,45,30,98,101,30,4]sortVArray.sorted()//结果：[4, 10, 20, 30, 30, 45, 98, 101]
print(sortVArray)//结果：[4, 10, 20, 30, 30, 45, 98, 101]
//25、交换数组两个元素。
var swapArray =  [10,20,45,30,98,101,30,4]
swapArray.swapAt(swapArray.startIndex, swapArray.endIndex-1)
print(swapArray)//[4, 20, 45, 30, 98, 101, 30, 10]
  • 字符串数组的拼接操作
  1. Joined（）拼接字符串里的所有元素为一个字符串。
  2. Joined(separator:)以给定的分隔拼接字符串数组里的所有元素作为一个字符串。
  • 元素为Sequence 数组的拼接。
  1. Joined()拼接数组里的所有元素为一个更大的sequence。
  2. Joined(separator:)以给定的分隔符拼接数组的所有元素为一个更大的sequence。
  • 数组的协议结构
  1. Sequence--> collection-->rangereplaceablecollection-->array
  • Sequence
  1. 一个序列（sequence）代表的是一系列具有相同类型的值，你可以对这些值进行迭代。
  • IleratorPritocol
  1. sequence通过创建一个迭代器来提供对元素的访问。迭代器每次产生一个序列值，并且当遍历序列时对遍历状态进行管理。
  2. 当序列被耗尽时，next（）应返回nil。
  • Collection是满组以下两个条件的sequence。
  1. 稳定的sequence，能够被多次遍历且保持一致。
  2. 除了线性遍历以外，集合中的元素也可以通过下标索引的方式被获取到。
  3. 和sequence不同，collection类型不能是无限的。
  • 【代码演示】 
    //26、字符串数组拼接
var joinArray = ["hellow","world"]
print(joinArray.joined())//结果：hellowworld
print(joinArray.joined(separator: ","))//结果：hellow,world
//27、元素为Sequence 数组的拼接。
let joinRanges = [0...3,8...10,15...17]
for range  in joinRanges{print(range)
}
/**结果：0...38...1015...17*/
for range  in joinRanges.joined(){print(range)
}
/** 0 1 2 3 8 9 10 15 16 17*/let nestedArray = [[1,2,3],[4,5,6],[7,8,9]]
let nestedArrayResule = nestedArray.joined(separator: [0,0])
print(nestedArrayResule)
/**结果JoinedSequence<Array<Array<Int>>>(_base: [[1, 2, 3], [4, 5, 6], [7, 8, 9]], _separator: ContiguousArray([0, 0]))*/
print(Array(nestedArrayResule))
/**转为结果:[1, 2, 3, 0, 0, 4, 5, 6, 0, 0, 7, 8, 9]*/
  • Stack
  1. 栈是一种后入先出的数据结构，仅限定在栈顶进行插入或者删除操作。栈结构的实际应用主要有数制表、转换，括号匹配，表达式求值等等。
  • Queue
  1. 队列在生活中非常常见。队列特点：先进先出（FIFO，first in first out）,排在最前面的先出来，后面来的只能排在最后面。
  • 【代码演示】 
    //27、模拟进出栈
struct Stack<T> {private var elements = [T]()var isEmpty : Bool{return elements.isEmpty}mutating func push(_ element:T) {elements.append(element)}mutating func pop () -> T? {return elements.popLast()}
}var stack = Stack<Int>()stack.push(1)
stack.push(6)
stack.push(8)
print(stack.pop() ?? 0)//27、模拟队列
struct Queue<T> {
private var elelments = [T]()var count:Int {return elelments.count}var isEmpty:Bool {return elelments.isEmpty}mutating func enqueue(_ element: T) {elelments.append(element)}mutating func dequeue() -> T? {return isEmpty ? nil :elelments.removeFirst()}
}
var queue = Queue<Int>()queue.enqueue(1)
queue.enqueue(6)
queue.enqueue(8)
print(queue.dequeue() ?? 0)

  相关解决方案

代码迷 - 您身边的软件异常，代码异常，编程异常助手（发现，解决，分享）
Copyright © 2009-2013 DAIMAMI.COM. All rights reserved.