swift5.x 数组(Array)的基本操作

//
//  ViewController2.swift
//  swiftT
//
//  Created by wjwdive on 2020/5/15.
//  Copyright @ wjwdive All rights reserved.
//

import UIKit

class ViewController2: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        //字面量 创建空数组
        let array:[Int] = []
        //字面量
        let array1: [String] = []
        //字面量
        let arrNums = [1, 2, 3, 4]
        print("array : ", array, "type array: ", type(of: array) )    //[] 空数组
        print("array1 : ", array1, "type array1: ", type(of: array1))    //[] 空数组
        print("arrNums : ", arrNums, "type of arrNums : ", type(of: arrNums))

        let arrStr = [""]
        print("arrStr : ", arrStr, "type of arrStr : ", type(of: arrStr))
        
        //初始化器
        var chars = Array("Jarvis")
        print(chars)
        
        let numbers = Array(1...9)
        print(numbers)
        
        //用字典的键初始化
        let persons = ["Jarvis": 18, "Marvis": 19, "Harvis": 20]
        let names = Array(persons.keys)
        print(names)
        
        
        //使用初始化器 创建空数组
        //1、[类型]()
        //2、Array<类型>()
        
        //初始化器参数
        // init(repeating repeatedValue: Element, count: Int)
        // init(arrayLiteral elements: Element...)
        // init<S>(_ elements: S) where S: Sequence, Self.Element == S.element
        // init(from decoder: Decoder) throws
        
        
        //数组的遍历方法
        // for-in 循环
        // forEatch 循环 ， 不能使用break, continue跳出整个循环,使用return 只能退出一次循环
        // enumerated() ,同时得到 索引和值
        
        let numberss = [1,2,3,4,5]
        //enumberated() 遍历
        for (index, num) in numberss.enumerated() {
            print("index ", index, " num ", num)
        }
        
        //for in遍历
        for i in 0..<numberss.count {
            print("the index is (i)")
            print(numberss[i])
        }
        
        // iterator 遍历
        var it = numberss.makeIterator()
        while let num = it.next() {
            print(num)
        }
        
        // indeces
        for i in numberss.indices {
            print("the index is (i)")
            print(numberss[i])
        }
        
        // 判断是否包含指定元素
        // contains(_:) 判断数组是否包含给定元素
        // contains(where:) 判断数组是否包含复合给定条件的元素
        // allSatisfy(_:) 判断数组的每一个元素都符合给定个的条件
        let arrt = [1, 2, 34, 17, 28]

        print("arrt contains 1 ",arrt.contains(1))
        print("arrt contains > 10 element ",arrt.contains(where: {$0 > 10}))
        
        
        
        //查找元素
        //  first  返回数组第一个元素（optional）, 如果数组为空，返回nil
        //  last 返回数组最后一个元素（optional）, 如果数组为空， 返回nil
        //  first(where:) 返回数组第一个符合条件的元素（optional），
        //  last(where:) 返回数组最后一个符合条件的元素（optional），
        print("arrt first element ", arrt.first)
        print("arrt last element ", arrt.last)
        
        //查找索引
        //  firstIndex(of:) 返回给定的元素在数组中出现的第一个位置
        //  lastIndex(of:)  返回给定的元素在数组中出现的最后一个位置
        //  firstIndex(where:{$0 > 10}) 返回符合条件的第一个元素索引
        //  lastIndex(where:{$0 > 10}) 返回符合条件的最后一个元素索引
        print("arrt fisrtIndex ", arrt.firstIndex(of: 2))
        print("arrt lartIndex ", arrt.lastIndex(of: 2))
        print("arrt firstIdex where arrt {$0 > 25}", arrt.firstIndex(of: 34))
        print("arrt lastIdex where arrt {$0 > 25}", arrt.lastIndex(of: 34))

        

        
        
        //返回最小，最大值
        //  min()
        //  max()
        
        //安装给定的方式比较元素并返回数组中的最小元素
        //  min(by:)
        //利用给定的方式比较元素并返回最大元素
        //  max(by:)
        
        let arrTuple = [(45, "error1"), (23, "error2"), (30, "error3")]
        print(arrTuple.min {a, b in a.0 < b.0})// Optional((23, "error2"))

        print(arrTuple.max {a, b in a.0 < b.0})//   Optional((45, "error1"))
        
        print(arrTuple.min(by: { (a, b) -> Bool in
            a.0 < b.0
        }))//   Optional((23, "error2"))

        //比较的是 error1,error2, error3
        print(arrTuple.max(by: { (a, b) -> Bool in
            a.1 < b.1
        }))//   Optional((30, "error3"))

        
        
        //数组的添加和删除
        // 1、 append(_:)        在数组末尾添加一个元素
        // 2、 append(contentsOf:)   在数组末尾添加多个元素
        // 3、 insert(_: at) 在指定位置插入一个元素
        // 4、 insert(contentsOf: at: )  在指定位置插入多个元素
        
        // i移除单个元素
         //1、remove(at:) 移除并返回指定位置的一个元素
         //2、removeFirst() 移除并返回数组的第一个元素
         //3、popFirst() 移除并返回数组中的第一个元素，数组为空时返回nil
         //4、removeLast() 移除并返回数组的最后一个元素
        
        var numbs: [Int] = [Int](2...7)
        print("numbs 
", numbs)
        numbs.append(8)
        print("numbs.append ", numbs)
        numbs.append(contentsOf: 100...110)
        print("numbs.append(contentsOf: 100...110) 
", numbs)
        numbs.insert(1, at: 0)
        print(" numbs.insert(1, at: 0) 
", numbs)
        numbs.insert(contentsOf: 200...205, at: numbs.endIndex)
        print("numbs.insert(contentsOf: 200...205, at: numbs.endIndex) 
",numbs)
        
        numbs.remove(at: 1)
        print("numbs.remove(at: 1) 
",numbs)
        
        numbs.removeFirst()
        print("removeFirst 
", numbs)
        
        numbs.removeLast()
        print("removeLast 
", numbs)
        
        let n1 = numbs.popLast()
        print("numbs.popLast() 
", n1)

        //移除单个元素
        //1、 removeSubrange(_:)
        //2、 removeAll()
        //3、 removeAll(keepingCapacity:) 移除数组所有元素，保留数组容量
        
        numbs.removeSubrange(1...3)
        print("numbs.removeSubrange(1...3) 
", numbs)

        numbs.removeAll(keepingCapacity: true)
        print("numbs.removeAll(keepingCapacity: true) 
", numbs)
        
        // 字符串也是 collection, Element 是 Character类型
        var charss: [Character] = ["a", "b", "c"]
        charss.insert(contentsOf: "hello", at: 0)
        print(charss)
        
        var chs: [Character] = ["a", "b", "c"]
        let removedChar = chs.remove(at: 1)
        print(removedChar)
        print(chs)
        
        var chs1: [Character] = ["a", "b", "c"]
        let removedChar1 = chs1.removeFirst()
        print(removedChar1)
        print(chs1)
        

        
        //数组切片
        //1、 ArraySlice 是数组或者其他ArraySlice 的一段连续切片，和原数组共享内存
        //2、 当要改变 ArraySlice 的时候， ArraySlice 会copy出来，形成单独内存
        //3、 ArraySlice 拥有和 Array 基本类似的方法
        
  
        
        
        // 通过 Drop 得到ArraySlice
        // dropFirst(:)  移除元数组前面指定个数的元素，得到一个ArraySlice
        // dropLast(:)  移除原数组后面指定个数的元素得到一个 ArraySlice
        // drop(:)  移除原数组符合指定条件的元素，得到一个 ArraySlice
        let arrayS = [1, 2, 3, 4, 5, 6]
        print("待切片原数组： arrayS: 
 ", arrayS)//[1, 2, 3, 4, 5, 6]
        let slice1 = arrayS.dropFirst()
        print("arrayS.dropFirst(): 
", slice1)//[2, 3, 4, 5, 6]

        let slice2 = arrayS.prefix(3)
        print("arrayS.prefix(3): 
",slice2)// [1, 2, 3]

        let slicew = arrayS.prefix(while:{
          $0 < 2
        })
        print(" arrayS.prefix(while : 
", slicew)// arrayS.prefix(while : [1]


        //通过prefix 得到ArraySlice
        //1、 prefix()  获取数组前面指定个数的元素组成的 ArraySlice
        //2、 prefix(upTo:)  获取数组到指定位置，（不包含指定位置）前面的元素组成的ArraySlcie
        //3、 prefix(through:) 获取数组到指定位置（包含指定位置）前面的元素组成的 ArraySlice
        //4、 prefix(while:) 获取数组前面符合条件的元素，（到第一个不符合条件的元素截止） 组成的 ArraySlice
        
        //通过suffix得到ArraySlice
        //suffix() 获取数组后面指定个数的元素组成的ArraySlice
        //suffix(from:) 获取数组从指定位置到结尾（包含指定位置）的元素组成的ArraySlice
        
        //通过range 得到ArraySlice
        //可以通过对数组下标指定Range 获取 ArraySlice, 可以使用 闭区间，半开半闭区间，单侧区间，... 得到整个数组的ArraySlice
        
        //ArraySlice 转换为 Array
        //ArraySlice 无法直接赋值给一个Array的常量或者变量，需要使用Array(slice)
        
        //ArraySlcie  和 原Array 是相互独立的
        // ArraySlcie  和 原Array 是相互独立的，他们添加删除元素不会影响对方
        
    }
   

}