• Swift 数组详细用法

    2016-10-31 23:59:12
    Swift 数组详细用法

    一、声明
    swift数组中的类型必须一致,这一点与OC不同

    // 数组初始化
    var numbers = [0,1,2,3,4,5]
    var vowels  = ["A","E","I","O","U"]
    
    // 数组的类型: [Int] 或者 Array<Int>
    //var numbers: [Int] = [0,1,2,3,4,5]
    //var numbers: Array<Int> = [0,1,2,3,4,5]
    
    // 空数组
    var emptyArray1:[Int] = []
    var emptyArray2:Array<Int> = []
    var emptyArray3 = [Int]()
    var emptyArray4 = Array<Int>()
    
    // 创建具有默认值的数组(相同元素的数组)
    var allZeros = Array<Int>(repeating: 0, count: 5)
    //[0,0,0,0,0]
    var allZeros2 = [Int](repeating: 0, count: 5)
    //[0,0,0,0,0]

    二、常用方法

    var numbers = [1,2,3,4,5]
    var vowels = ["A","E","I","O","U"]
    var emptyArray = [Int]()
    
    
    // 数组长度
    vowels.count
    
    
    // 判空
    numbers.isEmpty
    emptyArray.isEmpty
    
    
    // 获取元素
    vowels[2]
    // 数组越界是一个严重的错误
    //vowels[-1]
    //vowels[5]
    
    
    // 获取第一个元素和最后一个元素,返回的是可选型
    vowels.first  
    vowels.last   //.first和.last的返回值都为可选型
    emptyArray.first
    
    if let firstVowel = vowels.first{
        print("The first vowel is " + firstVowel)
    }
    
    vowels.first!
    
    vowels[vowels.count-1]
    
    // 获取最小,最大值
    numbers.min() //1
    vowels.max()  //U
    
    
    // 使用范围
    numbers[2..<4]  //[3,4]
    numbers[2..<numbers.count]  //[3,4,5]
    
    
    // 包含
    vowels.contains("A")
    vowels.contains("B")
    
    let letter = "A"
    if vowels.contains( letter ){
        print("\(letter) is a vowel")
    }
    else{
        print("\(letter) is not a vowel")
    }
    
    
    vowels.index(of: "E")  //获取索引,返回值为可选型
    
    if let index = vowels.index(of: "E"){
        print("E is a vowel in position \(index+1).")
    }
    else{
        print("E is not a vowel.")
    }
    
    
    // 遍历
    for index in 0..<numbers.count{
        numbers[index]
    }
    
    for number in numbers{
        print(number)
    }
    
    for (index, vowel) in vowels.enumerated(){
        //遍历数组索引和元素
        print("\(index+1): \(vowel)")
    }
    
    
    // 比较
    var oneToFive = [1,2,3,4,5]
    numbers == oneToFive  //true
    
    var oneToFive2 = [1,2,4,3,5]
    numbers == oneToFive  //true
    
    //swift 3.0之前数组是有序的数据集合,swift 3.0后为无序

    三、更多操作

    var courses = ["A","B","C"]
    
    // 添加元素
    courses.append("D")  //["A","B","C","D"]
    print(courses)
    
    // 数组常量
    //使用let定义的数组不可以更改任何内容
    
    courses += ["E"]  //+=后面必须和前面的类型一致 //["A","B","C","D","E"]
    print(courses)
    
    // 两个数组相加
    courses = courses + ["F","G"]  //+后面必须是数组
    //["A","B","C","D","E","F","G"]
    print(courses)
    
    courses.insert("Q", at: 5)  
    //["A", "B", "C", "D", "E", "Q", "F", "G"]
    print(courses)
    
    
    // 删除元素
    courses.removeLast()
    //["A", "B", "C", "D", "E", "Q", "F"]
    print(courses)
    
    courses.removeFirst()
    //["B", "C", "D", "E", "Q", "F"]
    print(courses)
    
    courses.remove(at: 4)
    //["B", "C", "D", "E", "F"]
    //courses.removeAtIndex(10)
    print(courses)
    
    
    //区间删除操作
    //courses.removeRange(0..<4)
    //courses.removeRange(0..<10)
    //print(courses)
    
    //courses.removeAll()
    //print(courses)
    
    
    // 修改元素
    courses[0] = "W"
    //["W", "C", "D", "E", "F"]
    print(courses)
    //范围修改
    courses[1...3] = ["W","W","W"]
    //["W", "W", "W", "W", "F"]
    print(courses)
    
    courses[0...3] = ["W"]
    //["W", "F"]
    print(courses)
    

    四、二维数组

    var board = [ [1024,16,2,0] , [256,4,2,0] , [64,2,0,0] , [2,0,0,0] ]
    //var board:[[Int]] = [ [1024,16,2,0] , [256,4,2,0] , [64,2,0,0] , [2,0,0,0] ]
    //var board:[Array<Int>] = = [ [1024,16,2,0] , [256,4,2,0] , [64,2,0,0] , [2,0,0,0] ]
    //var board:Array<[Int]> = [ [1024,16,2,0] , [256,4,2,0] , [64,2,0,0] , [2,0,0,0] ]
    //var board:Array<Array<Int>> = [ [1024,16,2,0] , [256,4,2,0] , [64,2,0,0] , [2,0,0,0] ]
    
    
    // 二维数组获取元素
    board[0]
    board[0][0]
    
    
    // 获取二维数组两个维度的信息
    board.count
    board[0].count
    
    
    // Swift中的二维数组,每一维度的元素数目可以不同
    board[0].append(0)
    board
    
    
    // 为二维数组的第一个维度添加的元素是一个数组
    board.append([0,0,0,0])
    board += [ [0,0,0,0] ]
    board
    

    五、NSArray
    NSArray是一个类,Array是一个结构体

    var array1 = []  //会默认是NSArray,swift3.0之后该写法废除
    
    var array2 = [1,2,3,4,5] as NSArray
    
    var array3: NSArray = [1,"hello"]
    
    var array4: [NSObject] = [1 as NSObject,"hello" as NSObject]
    
    展开全文
  • 【Swift初见】Swift数组

    2015-02-27 20:25:04
    在Objective-C中数组是常用的数据类型,在Swift中同样如此,在OC中有NSArray与NSMutableArray之分,但是在Swift中只有通过let和var来区分数组是否可变,Swift中的数组是类型安全的,所以在某个数据被存入到某个数组...
    在Objective-C中数组是常用的数据类型,在Swift中同样如此,在OC中有NSArray与NSMutableArray之分,但是在Swift中只有通过let和var来区分数组是否可变,Swift中的数组是类型安全的,所以在某个数据被存入到某个数组之前类型必须明确,假如我们创建了一个String类型的数组,那么该数组中就不能添加非String的数据类型,这是Swift与OC的一个很重要的区别。

    数组的构造
    我们以创建一个数组并存储Int类型的数组为例:
    var array = [2, 3, 4, 5]
    var array1: Array = [2, 3, 4, 5]
    var array2: Array<Int> = [2, 3, 4, 5]
    var array3: [Int] = [2, 3, 4, 5]
    

    数组的数量:数组有一个只读属性 count来获取数组中的数据项数量。
    array.count

    检查数组是否为空可以用isEmpty来检查count是否为0
    if array.isEmpty {
        println("array is Empty")
    }else{
        println("array is not Empty")
    }

    当要在数组后面添加新的数据项时可以使用append方法来添加:
    array .append(6)

    此时数组中就有5个值了,
    当数组的数据类型为字符串时,也可以使用加法赋值运算符(+=)直接在数组的后面添加新的数据项;
    加法运算符也可以直接添加拥有相同类型的数组:
    array += [7,8]

    获取数组中数据项的时候,可以用索引来获取值:
    var intV = array[0]

    注:不管是OC还是Swift,数组的索引都是从0开始。

    修改数组中的某一项时,也可以通过索引来改变:
    array[0] = 9

    此时数组就为:[9, 3, 4, 5, 6, 7, 8]
    swift中也可以通过下标一次性改变多个数据值:
    array[1...3] = [10,11,12]

    此时数组值就是:[9, 10, 11, 12, 6, 7, 8]
    在数组尾部添加新项时,不能使用下标来添加新项,此时数组越界,会引发一个运行期错误。

    在某个具体索引值之前添加数据项,调用数组的insert(atIndex)来添加:
    array.insert(13, atIndex: 0)

    此时的数组值为:[13, 9, 10, 11, 12, 6, 7, 8]

    同样的,移除数组的某一项时用removeAtIndex 方法;
    移除最后一项的时候用removeLast

    数组遍历
    普遍的我们使用for-in循环来遍历数组中的所有数据项
    for i in array {
        println(i)
    }


    swift提供一个enumerate函数来遍历数组,会同时返回数据项和索引值:
    for (index, value) in enumerate(array){
        println("index : \(index) value: \(value)")
    }


    此时打印的值为:
    index : 0 value: 13
    index : 1 value: 9
    index : 2 value: 10
    index : 3 value: 11
    index : 4 value: 12
    index : 5 value: 6
    index : 6 value: 7
    index : 7 value: 8

    如果我们需要创建一个数组,该数组有特定的大小并且所有的数据都是被默认的,此时swift提供了一个数组构造函数:
    var newArray = [String](count: 4, repeatedValue: "test")

    当然,swift具有类型推断功能,我们也可以如下定义:
    var newArray2 = Array(count: 3, repeatedValue: "today")

    我们知道,两种数据项类型相同的数组我们可以通过(+)来组合到一起形成一个新的数组:
    var newArray3 = newArray + newArray2


    欢迎大家共同学习指导。
    展开全文
  •  Swift 数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。 Swift 数组会强制检测元素的类型,如果类型不同则会报错,Swift 数组应该遵循像Array这样的形式,其中Element是这个...

    Swift 数组

        Swift 数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。

    Swift 数组会强制检测元素的类型,如果类型不同则会报错,Swift 数组应该遵循像Array<Element>这样的形式,其中Element是这个数组中唯一允许存在的数据类型。

    如果创建一个数组,并赋值给一个变量,则创建的集合就是可以修改的。这意味着在创建数组后,可以通过添加、删除、修改的方式改变数组里的项目。如果将一个数组赋值给常量,数组就不可更改,并且数组的大小和内容都不可以修改。

    创建数组

    我们可以使用构造语法来创建一个由特定数据类型构成的空数组:

    var someArray = [SomeType]()

    以下是创建一个初始化大小数组的语法:

    var someArray = [SomeType](count: NumbeOfElements, repeatedValue: InitialValue)

    以下实例创建了一个类型为 Int ,大小为 3,初始值为 0 的空数组:

    var someInts = [Int](count: 3, repeatedValue: 0)

    以下实例创建了含有三个元素的数组:

    var someInts:[Int] = [10, 20, 30]

    访问数组

    我们可以根据数组的索引来访问数组的元素,语法如下:

    var someVar = someArray[index]

    index 索引从 0 开始,及索引 0 对应第一个元素,索引 1 对应第二个元素,以此类推。

    我们可以通过以下实例来学习如何创建,初始化,访问数组:

    import Cocoa


    var someInts = [Int](repeating : 10,count : 3)


    var someVar = someInts[0]


    print( "第一个元素的值 \(someVar)" )

    print( "第二个元素的值 \(someInts[1])" )

    print( "第三个元素的值 \(someInts[2])" )

    以上程序执行输出结果为:

    第一个元素的值 10

    第二个元素的值 10

    第三个元素的值 10

    修改数组

    你可以使用 append() 方法或者赋值运算符 += 在数组末尾添加元素,如下所示,我们初始化一个数组,并向其添加元素:

    import Cocoa


    var someInts = [Int]()


    someInts.append(20)

    someInts.append(30)

    someInts += [40]


    var someVar = someInts[0]


    print( "第一个元素的值 \(someVar)" )

    print( "第二个元素的值 \(someInts[1])" )

    print( "第三个元素的值 \(someInts[2])" )

    以上程序执行输出结果为:

    第一个元素的值 20

    第二个元素的值 30

    第三个元素的值 40

    我们也可以通过索引修改数组元素的值:

    import Cocoa


    var someInts = [Int]()


    someInts.append(20)

    someInts.append(30)

    someInts += [40]


    // 修改最后一个元素

    someInts[2] = 50


    var someVar = someInts[0]


    print( "第一个元素的值 \(someVar)" )

    print( "第二个元素的值 \(someInts[1])" )

    print( "第三个元素的值 \(someInts[2])" )

    以上程序执行输出结果为:

    第一个元素的值 20

    第二个元素的值 30

    第三个元素的值 50

    遍历数组

    我们可以使用for-in循环来遍历所有数组中的数据项:

    import Cocoa


    var someStrs = [String]()


    someStrs.append("Apple")

    someStrs.append("Amazon")

    someStrs.append("Runoob")

    someStrs += ["Google"]


    for item in someStrs {

       print(item)

    }

    以上程序执行输出结果为:

    Apple

    Amazon

    Runoob

    Google

    如果我们同时需要每个数据项的值和索引值,可以使用 String 的 enumerate() 方法来进行数组遍历。实例如下:

    import Cocoa


    var someStrs = [String]()


    someStrs.append("Apple")

    someStrs.append("Amazon")

    someStrs.append("Runoob")

    someStrs += ["Google"]


    for (index, item) in someStrs.enumerated() {

        print("在 index = \(index) 位置上的值为 \(item)")

    }

    以上程序执行输出结果为:

    在 index = 0 位置上的值为 Apple

    在 index = 1 位置上的值为 Amazon

    在 index = 2 位置上的值为 Runoob

    在 index = 3 位置上的值为 Google

    合并数组

    我们可以使用加法操作符(+)来合并两种已存在的相同类型数组。新数组的数据类型会从两个数组的数据类型中推断出来:

    import Cocoa


    var intsA = [Int](repeating: 2, count:2)

    var intsB = [Int](repeating: 1, count:3)


    var intsC = intsA + intsB


    for item in intsC {

        print(item)

    }

    以上程序执行输出结果为:

    2

    2

    1

    1

    1

    count 属性

    我们可以使用 count 属性来计算数组元素个数:

    import Cocoa


    var intsA = [Int](repeating: 2, count:2)

    var intsB = [Int](repeating: 1, count:3)


    var intsC = intsA + intsB


    print("intsA 元素个数为 \(intsA.count)")

    print("intsB 元素个数为 \(intsB.count)")

    print("intsC 元素个数为 \(intsC.count)")

    以上程序执行输出结果为:

    intsA 元素个数为 2

    intsB 元素个数为 3

    intsC 元素个数为 5

    isEmpty 属性

    我们可以通过只读属性 isEmpty 来判断数组是否为空,返回布尔值:

    import Cocoa


    var intsA = [Int](repeating: 2, count:2)

    var intsB = [Int](repeating: 1, count:3)

    var intsC = [Int]()


    print("intsA.isEmpty = \(intsA.isEmpty)")

    print("intsB.isEmpty = \(intsB.isEmpty)")

    print("intsC.isEmpty = \(intsC.isEmpty)")

    展开全文
  • swift 数组关于引用问题

    swift 数组关于引用问题
    这里写图片描述

    展开全文
  • Swift数组定义和操作

    2017-11-22 23:18:37
    swift数组中的类型必须一致,这一点与OC不同 // 数组初始化 var numbers = [0,1,2,3,4,5] var vowels = ["A","E","I","O","U"] // 数组的类型: [Int] 或者 Array //var numbers: ...


    一、声明 

    swift数组中的类型必须一致,这一点与OC不同


    // 数组初始化

    var numbers = [0,1,2,3,4,5]

    var vowels  = ["A","E","I","O","U"]


    // 数组的类型: [Int] 或者 Array<Int>

    //var numbers: [Int] = [0,1,2,3,4,5]

    //var numbers: Array<Int> = [0,1,2,3,4,5]


    // 空数组

    var emptyArray1:[Int] = []

    var emptyArray2:Array<Int> = []

    var emptyArray3 = [Int]()

    var emptyArray4 = Array<Int>()


    // 创建具有默认值的数组(相同元素的数组)

    var allZeros = Array<Int>(repeating: 0, count: 5)

    //[0,0,0,0,0]

    var allZeros2 = [Int](repeating: 0, count: 5)

    //[0,0,0,0,0]


    二、常用方法


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

    var vowels = ["A","E","I","O","U"]

    var emptyArray = [Int]()



    // 数组长度

    vowels.count



    // 判空

    numbers.isEmpty

    emptyArray.isEmpty



    // 获取元素

    vowels[2]

    // 数组越界是一个严重的错误

    //vowels[-1]

    //vowels[5]



    // 获取第一个元素和最后一个元素,返回的是可选型

    vowels.first  

    vowels.last   //.first.last的返回值都为可选型

    emptyArray.first


    if let firstVowel = vowels.first{

        print("The first vowel is " + firstVowel)

    }


    vowels.first!


    vowels[vowels.count-1]


    // 获取最小,最大值

    numbers.min() //1

    vowels.max()  //U



    // 使用范围

    numbers[2..<4]  //[3,4]

    numbers[2..<numbers.count]  //[3,4,5]



    // 包含

    vowels.contains("A")

    vowels.contains("B")


    let letter = "A"

    if vowels.contains( letter ){

        print("\(letter) is a vowel")

    }

    else{

        print("\(letter) is not a vowel")

    }



    vowels.index(of: "E")  //获取索引,返回值为可选型


    if let index = vowels.index(of: "E"){

        print("E is a vowel in position \(index+1).")

    }

    else{

        print("E is not a vowel.")

    }



    // 遍历

    for index in 0..<numbers.count{

        numbers[index]

    }


    for number in numbers{

        print(number)

    }


    for (index, vowel) in vowels.enumerated(){

        //遍历数组索引和元素

        print("\(index+1): \(vowel)")

    }



    // 比较

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

    numbers == oneToFive  //true


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

    numbers == oneToFive  //true


    //swift 3.0之前数组是有序的数据集合,swift 3.0后为无序


    三、更多操作


    var courses = ["A","B","C"]


    // 添加元素

    courses.append("D")  //["A","B","C","D"]

    print(courses)


    // 数组常量

    //使用let定义的数组不可以更改任何内容


    courses += ["E"]  //+=后面必须和前面的类型一致 //["A","B","C","D","E"]

    print(courses)


    // 两个数组相加

    courses = courses + ["F","G"]  //+后面必须是数组

    //["A","B","C","D","E","F","G"]

    print(courses)


    courses.insert("Q", at: 5)  

    //["A", "B", "C", "D", "E", "Q", "F", "G"]

    print(courses)



    // 删除元素

    courses.removeLast()

    //["A", "B", "C", "D", "E", "Q", "F"]

    print(courses)


    courses.removeFirst()

    //["B", "C", "D", "E", "Q", "F"]

    print(courses)


    courses.remove(at: 4)

    //["B", "C", "D", "E", "F"]

    //courses.removeAtIndex(10)

    print(courses)



    //区间删除操作

    //courses.removeRange(0..<4)

    //courses.removeRange(0..<10)

    //print(courses)


    //courses.removeAll()

    //print(courses)



    // 修改元素

    courses[0] = "W"

    //["W", "C", "D", "E", "F"]

    print(courses)

    //范围修改

    courses[1...3] = ["W","W","W"]

    //["W", "W", "W", "W", "F"]

    print(courses)


    courses[0...3] = ["W"]

    //["W", "F"]

    print(courses)


    四、二维数组


    var board = [ [1024,16,2,0] , [256,4,2,0] , [64,2,0,0] , [2,0,0,0] ]

    //var board:[[Int]] = [ [1024,16,2,0] , [256,4,2,0] , [64,2,0,0] , [2,0,0,0] ]

    //var board:[Array<Int>] = = [ [1024,16,2,0] , [256,4,2,0] , [64,2,0,0] , [2,0,0,0] ]

    //var board:Array<[Int]> = [ [1024,16,2,0] , [256,4,2,0] , [64,2,0,0] , [2,0,0,0] ]

    //var board:Array<Array<Int>> = [ [1024,16,2,0] , [256,4,2,0] , [64,2,0,0] , [2,0,0,0] ]



    // 二维数组获取元素

    board[0]

    board[0][0]



    // 获取二维数组两个维度的信息

    board.count

    board[0].count



    // Swift中的二维数组,每一维度的元素数目可以不同

    board[0].append(0)

    board



    // 为二维数组的第一个维度添加的元素是一个数组

    board.append([0,0,0,0])

    board += [ [0,0,0,0] ]

    board


    五、NSArray 

    NSArray是一个类,Array是一个结构体


    var array1 = []  //会默认是NSArray,swift3.0之后该写法废除


    var array2 = [1,2,3,4,5] as NSArray


    var array3: NSArray = [1,"hello"]


    var array4: [NSObject] = [1 as NSObject,"hello" as NSObject]

    展开全文
  • Swift数组的类型是Array,这里的SomeType是某种数组能够存放的类型。你也可以把数组类型简写为SomeType[]。尽管这两种形式功能上是一样的,我们更偏向于使用简写形式. 可以用一个数组字面量来初始化一个数组,简单...
  • 不要使用额外的数组空间,你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。 示例:nums=[3,2,2,3],val=3,执行方法后得到 的新数组是...
  • Swift(06)- 数组

    2019-05-14 18:19:58
    swift数组类型是Array,是一个泛型集合 数组的初始化 数组分成:可变数组和不可变数组 使用let修饰的数组是不可变数组 使用var修饰的数组是可变数组 // 定义一个可变数组,必须初始化才能使用 var array1 : ...
  • 前两篇博客写了在使用swift写冒泡排序和选择排序,实在是遇到了很多坑,在使用forin循环时。也着实遇到了不少隐藏的点。但是swift 提供了可供使用的 排序的方法,如下图: var sortArr : [Float] = [9.54,5.88,2.09,...
  • Swift 数组的常用操作

    2015-08-14 16:14:10
    * Swift 要求一个数组要能正常使用 得满足两点 * 1,数组一定要初始化,初始化时可以赋值,也可以直接=[] 表示一个空数组 * * 2,必须要指定数据类型,可以通过赋值的方式让编译器自动识别数据类型,也可以...
  • 数组进行排序,根据指定的排序规则,看下面的代码: var array = [2, 3, 4, 5] array.sort{$0 $1} println(array) 此时打印出:[2, 3, 4, 5] 其实sort大括号里面是一个闭包,这个以后再学习。 如果倒叙排列,代码...
  • swift 数组部分排序

    2019-06-24 10:33:13
    数组自带排序函数,如果想实现部分排序,先对数组进行部分截取,然后对截取部分替换位排序好的子序列 var nums = [1,3,4,5,1,3,6] var sub = nums[3...6] nums.replaceSubrange(3...6, with: sub.sorted()) //...
  • 本文讲的是[译] 对元素持有弱引用的 Swift 数组, 原文地址:Swift Arrays Holding Elements With Weak References 原文作者:Marco Santarossa 译文出自:掘金翻译计划 译者:zhangqippp 校对者:...
  • swift应该都知道 删除某一个元素的时候提供的是 array.remove(at: &lt;#T##Int#&gt;)并没有提供按照 指定元素删除的方法。不是没有,是Array 支持更强到的值过滤能力。 Array.filterfilter方法支持 正则...
  • // 这里是var变量, 不能是常量  var array1 = [1, 2, 3, ...4, 5]   // 这样子就修改了第一个元素  array1[0] = 9    print(array1)    print("------------>")
  • Swift - Swift数组迭代

    2015-06-11 13:31:57
    依据不同情形, swift提供很多种方式对数组进行迭代 比如有如下数组: var heros = [ "Atani J", "Tirion Foordring", "Salou Farr", "Thrall", "Tassa Dahl" ] 1. 通过变量递增的for循环 func printHeros() { for...
  • swift自动为闭包提供参数名缩写功能,可以直接通过$0和$1等来表示闭包中的第一个第二个参数,并且对应的参数类型会根据函数类型来进行判断。并且in关键字也可以省略,只写函数体就可以了。 例如 arr.sorted { (a, b)...
  • Swift 数组Array

    2014-11-13 23:47:22
    一天一点,好好学习 前进就是动力,动力推动前进 ...Swift 数组特定于它所存储元素的类型。这与 Objective-C 的 NSArray 和 NSMutableArray 不同,这两个类可以存储任意类型的对象,并且不提供所返回对象的任何特别信息
  • /**  数组元素的访问  和在数组中插入或者增加元素  */    var array1 = ["a", "b", "c"]  // 不能越界  print(array1[1])      print("---
  • ios Swift 数组初始化

    2018-03-16 03:31:16
    数组初始化调用Array.init(repeating: UIButton(), count: 6) 为啥数组中只有6个按钮,但是是同一个对象。不是应该创建六个不同的对象吗?![图片说明]...
1 2 3 4 5 ... 20
收藏数 20,438
精华内容 8,175