iOS - Swift Array 数组

2016-08-15 481

前言

    public struct Array<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer
    public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSFastEnumeration

在 Swift 语言中，数据在被存储进某个数组之前，类型必须明确，且与数组其他元素类型相同。在 Swift 语言中的数组和 C 语言中的不同，Swift 语言中的数组是值类型的，不管是赋值还是当作参数传递，都只是维护他的拷贝。你可以放心的操作他的拷贝，因为你做的任何操作都不会反馈回它本身，这是值类型自身的规则。

1、Array 与 NSArray 的相互转换

Array 与 NSArray 之间可以相互转换。Array 转成 NSArray 时，数组中的各项元素被转换为 AnyObject 类型。NSArray 转换成 Array 时，数组中的各项元素也被转换为 AnyObject 类型。

    // Array 转 NSArray
    
        // Array 转换成 NSArray<AnyObject> 型
        let nsArray1:NSArray = array
    
        // Array 转换成 NSArray<AnyObject> 型
        let nsArray2:NSArray = array as NSArray
        
    // NSArray 转 Array
    
        // NSArray 转换成 Array<AnyObject> 型
        let swiftArray1:Array = nsArray1 as Array
    
        // NSArray 转换成 Array<AnyObject> 型
        let swiftArray2:Array = nsArray1 as [AnyObject]
    
        // NSArray 转换成 Array<Int> 型
        let swiftArray3:Array = nsArray1 as! [Int]

2、数组的创建

    // Array 型数组
            
        // 不赋初值，指定数组内数据为 String 型
        let array1 = [String]()
        
        // 不赋初值，Array<String> 等价于 [String]
        let array2 = Array<String>()
        
        // 不指定数组内数据类型，自动推断
        let array3:Array = ["bei", "jing"]
        
        // 指定数组内数据类型为 String 型
        let array4:Array<String> = ["huan", "ying", "ni"]
        
        // 不指定数组内数据类型，自动推断
        let array5 = ["bei", "jing", "huan", "ying", "ni"]
        
        // 指定数组内数据类型为 Int 型
        let array6:[Int] = [1, 2, 3, 4, 5, 6]
        
        // 指定数组内数据类型为 AnyObject 型
        let array7:[AnyObject] = [1, 2, 3, 4, 5, 6, "happy"]
        
        // 创建二维数组
        let array8:Array<Array<Int>> = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
        
    // NSArray 型数组
            
        let swiftArray:Array = ["bei", "jing", "nin", "hao"]
            
        let nsArray1:NSArray = swiftArray
        let nsArray2:NSArray = swiftArray as NSArray
            
        let nsArray3 = NSArray()
            
        // array: [AnyObject]
        let nsArray4 = NSArray(array: array7)
        
        // array: [AnyObject]
        let nsArray6 = NSArray(array: ["bei", "jing", "huan", "ying", "ni"])
        
        // array: NSArray
        let nsArray5 = NSArray(array: nsArray2)
        
        // object: AnyObject
        let nsArray7 = NSArray(object: "qian")
        
        // objects: AnyObject...
        let nsArray8 = NSArray(objects: "bei", "jing", "huan", "ying", "ni")
        
        // 从 文件 创建字符串
        let nsArray9:NSArray? = NSArray(contentsOfFile: NSHomeDirectory() + "/Desktop/test.txt")
        
        // 从 Url 创建字符串
        let nsArray10:NSArray? = NSArray(contentsOfURL: NSURL(fileURLWithPath: NSHomeDirectory() + "/Desktop/test.txt"))

3、数组的长度计算

    // Array 或 NSArray 型数组
    
        let array = ["bei", "jing", "huan", "ying", "ni"]
            
        let num:Int = array.count

4、数组位置的获取

    // Array 型字符串
            
        let array = ["bei", "jing", "huan", "ying", "ni"]
            
        // 获取起始位置，即 0
        let startIndex = array.startIndex
        
        // 获取结束位置，指 数组最后一个元素的位置
        let endIndex = array.endIndex
        
        // 获取指定位置下标值
        let index = array.startIndex.advancedBy(2)
        
        // 获取下标区间值
        let range = array.startIndex.advancedBy(4)...array.startIndex.advancedBy(6)
        
        // 获取指定位置下标的 前一个值
        let predecessorIndex = array.startIndex.advancedBy(2).predecessor()
        
        // 获取指定位置下标的 后一个值
        let successorIndex = array.startIndex.advancedBy(2).successor()

5、数组元素的获取

    // Array 型数组
            
        let array:Array = ["bei", "jing", "huan", "ying", "ni"]
            
        // 获取数组指定下标的元素
        let obj1:String = array[1]
        
        // 获取数组的第一个元素
        let obj2:String? = array.first
        
        // 获取数组的最后一个元素
        let obj3:String? = array.last
        
        // 获取数组指定范围内的元素
        let obj4 = array[2...4]

    // NSArray 型数组
            
        let nsArray:NSArray = ["bei", "jing", "huan", "ying", "ni"]
            
        // 获取指定下标元素，NSArray 中数据类型为 AnyObject
        let obj5:String = nsArray[2] as! String
        
        // 获取数组指定下标的元素
        let obj6:String = nsArray.objectAtIndex(2) as! String
        
        // 获取数组的第一个元素
        let obj7:String = nsArray.firstObject as! String
        
        // 获取数组的最后一个元素
        let obj8:String = nsArray.lastObject as! String
        
        // 获取数组指定范围内的元素
        let obj9 = nsArray.objectsAtIndexes(NSIndexSet(indexesInRange: NSMakeRange(2, 2)))
        
        // 获取数组指定范围内的元素
        let obj10 = nsArray.subarrayWithRange(NSMakeRange(2, 3))

6、数组下标的获取

    // Array 型数组
            
        let array:Array = ["bei", "jing", "huan", "ying", "ni"]
            
        // 获取指定元素的下标，若元素不存在，返回 nil
        let indexNum1:Int? = array.indexOf("huan")
            
    // NSArray 型数组
            
        let nsArray:NSArray = ["bei", "jing", "huan", "ying", "ni"]
            
        // 获取指定元素的下标，若元素不存在，返回 Int.max
        let indexNum2:Int = nsArray.indexOfObject("hun")

7、数组的判断

    // Array 型数组
            
        let arr1:Array = [1, 3, 5, 8]
        let arr2:Array = [1, 3, 7, 8]
            
        // 判断两个数组是否相等
        let bl1:Bool = arr1 == arr2
        
        // 判断数组是否为空
        let bl2:Bool = arr1.isEmpty
        
        // 判断数组中是否存在指定的元素
        let bl3:Bool = arr1.contains(55)
            
    // NSArray 型数组
            
        let nsArr1:NSArray = [2, 3, 5, 8]
        let nsArr2:NSArray = [1, 4, 7, 9]
            
        // 判断两个数组是否相等
        let bl4:Bool = nsArr1.isEqualToArray(nsArr2 as [AnyObject])
        
        // 判断数组中是否存在指定的元素
        let bl5:Bool = nsArr1.containsObject(7)
        
        // 返回两个数组中第一个相同的元素，没有时返回 nil
        let firstObj:AnyObject? = nsArr1.firstObjectCommonWithArray(nsArr2 as [AnyObject])

8、数组元素的组合

    // NSArray 型数组
            
        let arr1:NSArray = ["bei", "jing", "huan", "ying", "nin"]
        let arr2:NSArray = ["Users", "JHQ0228", "Desktop"]
            
        // 按指定字符组合
        let str1:String = arr1.componentsJoinedByString(" ")
        
        // 按路径组合
        let str2:String = NSString.pathWithComponents(arr2 as! [String])

9、数组元素的追加

    // Array 型数组
            
        var arr1:Array = ["bei", "jing"]
            
        // 使用 "+" 号连接两个数组
        let arr2 = arr1 + ["huan", "ying", "ni"]
        
        // 在数组末尾追加一个元素
        arr1.append("hao")
        
        // 在指定位置插入一个元素
        arr1.insert("ni", atIndex: 2)
            
    // NSArray 型数组
            
        let nsArray:NSMutableArray = ["jing", "huan"]
            
        // 向数组添加一个元素，返回一个新的数组
        let nsArray1 = nsArray.arrayByAddingObject("ma")
        
        // 在数组末尾追加一个元素
        nsArray.addObject("ni")
        
        // 在数组末尾追加一个数组
        nsArray.addObjectsFromArray(["ni", "hao"])
        
        // 在指定位置追加一个元素
        nsArray.insertObject("bei", atIndex: 0)

10、数组元素的删除

    // Array 型数组
            
        var arr1:Array = ["bei", "jing", "huan", "ying", "ni"]
            
        // 删除指定位置的数组元素
        arr1.removeAtIndex(3)
        
        // 删除数组中的最后一个元素
        arr1.removeLast()
        
        // 删除指定范围内的数组元素
        arr1.removeRange(0...1)
        
        // 删除所有数组元素
        arr1.removeAll(keepCapacity: true)
            
    // NSArray 型数组
            
        let nsArr1:NSMutableArray = ["nan", "jing", "huan", "ying", "nin", "bei", "jing", "ni", "hao"]
            
        // 删除指定下标的元素
        nsArr1.removeObjectAtIndex(2)
        
        // 删除指定元素，删除所有指定元素
        nsArr1.removeObject("ying")
        
        // 删除指定元素
        nsArr1.removeObjectIdenticalTo("nan")
        
        // 删除最后一个元素
        nsArr1.removeLastObject()
        
        // 删除指定范围的元素
        nsArr1.removeObjectsInRange(NSMakeRange(2, 1))
        
        // 删除所有元素
        nsArr1.removeAllObjects()

11、数组元素的替换

    // NSArray 型数组
            
        let nsArr:NSMutableArray = ["nan", "jing", "huan", "ying", "nin"]
            
        // 替换指定下标元素
        nsArr.replaceObjectAtIndex(0, withObject: "bei")
        
        // 替换的元素个数与被替换的元素个数需相等
        nsArr.replaceObjectsAtIndexes(NSIndexSet(indexesInRange: NSMakeRange(2, 3)), 
                          withObjects: ["ni", "hao", "ma"])
        
        // 用数组替换
        nsArr.replaceObjectsInRange(NSMakeRange(2, 3), withObjectsFromArray: ["huan", "ying"])
            
        nsArr.replaceObjectsInRange(NSMakeRange(0, 2), 
               withObjectsFromArray: ["huan", "ying", "nin", "nan", "jing", "huan"], 
                              range: NSMakeRange(3, 2))

12、数组元素的交换

    // NSArray 型数组
    let nsArr:NSMutableArray = ["bei", "jing", "huan", "ying", "nin"]
        
    nsArr.exchangeObjectAtIndex(2, withObjectAtIndex: 4)

13、数组元素的修改

    // Array 型数组
        
        var arr:Array = ["bei", "jing", "huan", "ying", "ni"]
            
        arr[0] = "nan"
            
        // NSArray 型数组
        let nsArr:NSMutableArray = ["bei", "jing", "huan", "ying", "nin"]
            
        // 修改数组中的某个元素
        nsArr[4] = "ni"
        
        // 修改整个数组（覆盖重写）
        nsArr.setArray(["ni", "hao"])

14、数组元素的过滤

    // Array 型数组
            
        let arr:Array = [1, 9, 2, 8, 45]
            
        let array:[Int] = arr.filter { (obj:Int) -> Bool in
            
            // 过滤掉不能被 3 整除的数
            return obj % 3 == 0
        }
            
    // NSArray 型数组
            
        let nsArr:NSMutableArray = [1, 9, 2, 8, 45]
            
        let nsArray:[AnyObject] = nsArr.filter { (obj:AnyObject) -> Bool in
            
            // 过滤掉不能被 3 整除的数
            return (obj as! Int) % 3 == 0
        }

15、数组的遍历

用 for...in 循环遍历

    // Array 或 NSArray 型数组

        let arr = ["bei", "jing", "huan", "ying", "ni"]

        // tmp 无需定义，在 Swift 2.2 中 C 语言样式的 for 循环语句被废弃
        for tmp in arr {

            print(tmp)
        }

用闭包循环遍历

    // NSArray 型数组

        let arr:NSArray = ["bei", "jing", "huan", "ying", "ni"]

        arr.enumerateObjectsUsingBlock { (obj:AnyObject, idx:Int, stop:UnsafeMutablePointer<ObjCBool>) in

            print(obj)

            if obj.isEqualTo("huan") {

                // 停止继续遍历
                stop.initialize(true)
            }
        }

用迭代器遍历

    // NSArray 型数组

        let arr:NSArray = ["bei", "jing", "huan", "ying", "ni"]

        // 正序遍历
        let enu1:NSEnumerator = arr.objectEnumerator()

        // 反序遍历
        let enu2:NSEnumerator = arr.reverseObjectEnumerator()

        // AnyObject 后不要加 ？，否则会导致一直循环
        while let obj:AnyObject = enu1.nextObject() {

            print(obj)
        }

条件遍历

    // NSArray 型数组

        let arr:NSArray = ["bei", "jing", "huan", "ying", "huan", "ni"]

        // 1. indexesOfObjectsPassingTest 找出数组中所有满足条件的值

            let indexSet:NSIndexSet = arr.indexesOfObjectsPassingTest { (obj:AnyObject, 
                                                                         idx:Int, 
                                                                        stop:UnsafeMutablePointer<ObjCBool>) -> Bool in

                // 条件满足时返回满足的数组元素的下标
                return obj.isEqualTo("huan") ? true : false
            }

            indexSet.enumerateIndexesUsingBlock { (idx:Int, stop:UnsafeMutablePointer<ObjCBool>) in

                print(idx)
            }

        // 2. indexOfObjectPassingTest 找出数组中第一个满足条件的值

            let index:Int = arr.indexOfObjectPassingTest { (obj:AnyObject, 
                                                            idx:Int, 
                                                           stop:UnsafeMutablePointer<ObjCBool>) -> Bool in

                // 条件满足时返回满足的数组元素的下标
                return obj.isEqualTo("huan") ? true : false
            }

            print(index)

16、数组的排序

冒泡排序

    // NSArray 型数组

        let array:NSMutableArray = ["bei", "jing", "huan", "ying", "ni"]

        for i in 0 ..< array.count - 1 {
            for j in 0 ..< array.count - 1 - i {

                // 大小判断 升序
                if (array[j] as! String).compare(array[j + 1] as! String) == NSComparisonResult.OrderedAscending {

                    // 位置交换
                    array.exchangeObjectAtIndex(j, withObjectAtIndex: j + 1)
                }
            }
        }
        print(array)

用闭包排序

    // Array 型数组

        // 1. 利用闭包进行排序，可变数组排序

            var varArray:Array = ["sunday", "sunny", "summer", "sun"];

            varArray.sortInPlace { (obj1:String, obj2:String) -> Bool in

                return obj1 < obj2
            }

            print(varArray)

        // 2. 利用闭包进行排序，不可变数组排序

            let letArray:Array = ["sunday", "sunny", "summer", "sun"];

            let array = letArray.sort { (obj1:String, obj2:String) -> Bool in

                return obj1 < obj2
            }

            print(array)

    // NSArray 型数组

        // 1. 利用闭包进行排序，可变数组排序

            let nsMArray1:NSMutableArray = ["sunday", "sunny", "summer", "sun"];

            nsMArray1.sortUsingComparator { (obj1:AnyObject, obj2:AnyObject) -> NSComparisonResult in

                let result:NSComparisonResult = (obj1 as! String).compare(obj2 as! String)

                return result
            }

            print(nsMArray1)

        // 2. 利用闭包进行排序，不可变数组排序

            let nsArray1:NSArray = ["sunday", "sunny", "summer", "sun"];

            let array1:NSArray = nsArray1.sortedArrayUsingComparator { (obj1:AnyObject, 
                                                                        obj2:AnyObject) -> NSComparisonResult in

                let result:NSComparisonResult = (obj1 as! String).compare(obj2 as! String)

                return result
            }

            print(array1)

用指定的方法排序

    // Array 型数组

        // 1. 用指定的方法排序，可变数组排序

            var varArray:Array = ["sunday", "sunny", "summer", "sun"];

            // 直接使用 Swift 数组类型中定义的小于号 (<) 实现，public func <(lhs: String, rhs: String) -> Bool
            varArray.sortInPlace( < )

            print(varArray)

        // 2. 用指定的方法排序，不可变数组排序

            let letArray:Array = ["sunday", "sunny", "summer", "sun"];

            // 直接使用 Swift 数组类型中定义的小于号 (<) 实现，public func <(lhs: String, rhs: String) -> Bool
            let array = letArray.sort( < )

            print(array)

    // NSArray 型数组

        // 1. 用指定的方法排序，可变数组排序

            let nsMArray1:NSMutableArray = ["sunday", "sunny", "summer", "sun"];

            // 原数组的顺序改变，指定元素的比较方法：compare:，默认为升序排列，
            // #selector(NSNumber.compare(_:)) 代替 Selector("compare:")
            nsMArray1.sortUsingSelector(#selector(NSNumber.compare(_:)))

            print(nsMArray1)

            // 使排序结果 降序 排列
            let enu:NSEnumerator = nsMArray1.reverseObjectEnumerator()

            while let obj:AnyObject = enu.nextObject() {
                print(obj)
            }

        // 2. 用指定的方法排序，不可变数组排序

            let nsArray1:NSArray = ["sunday", "sunny", "summer", "sun"];

            // 返回一个排好的数组，原数组的顺序不变，指定元素的比较方法：compare:
            let array1:NSArray = nsArray1.sortedArrayUsingSelector(#selector(NSNumber.compare(_:)))

            print(array1)

        // 3. 用指定的方法排序，自定义类

            // Student.swift

                class Student: NSObject {

                    var firstName:String
                    var lastName:String

                    init(firstName:String, lastName:String ) {

                        self.firstName = firstName
                        self.lastName = lastName
                    }

                    func compareStudent(stu:Student) -> NSComparisonResult {

                        // 先按照姓排序
                        var result:NSComparisonResult = self.lastName.compare(stu.lastName)

                        if result == NSComparisonResult.OrderedSame {

                            // 如果有相同的姓，就比较名字
                            result = self.firstName.compare(stu.firstName)
                        }
                        return result;
                    }

                    // 需遵守协议 Printable
                    override var description: String{

                        return String(format: "%@, %@", self.lastName, self.firstName)
                    }
                }

            // main.swift

                let stu1:Student = Student(firstName: "MingJie", lastName: "Li")
                let stu2:Student = Student(firstName: "LongHu", lastName: "Huang")
                let stu3:Student = Student(firstName: "LianJie", lastName: "Li")
                let stu4:Student = Student(firstName: "Jian", lastName: "Xiao")

                // 用指定的方法排序，可变数组排序

                    let nsMArray2:NSMutableArray = NSMutableArray(objects: stu1, stu2, stu3, stu4)

                    // 代替 Selector("compareStudent:")
                    nsMArray2.sortUsingSelector(#selector(Student.compareStudent(_:)))

                    print(nsMArray2)

                // 用指定的方法排序，不可变数组排序

                    let nsArray2:NSArray = NSArray(objects: stu1, stu2, stu3, stu4)

                    let array2:NSArray = nsArray2.sortedArrayUsingSelector(#selector(Student.compareStudent(_:)))

                    print(array2)

按描述器排序

    // Student.swift

        class Student: NSObject, Printable {

            var firstName:String
            var lastName:String

            init(firstName:String, lastName:String ) {

                self.firstName = firstName
                self.lastName = lastName
            }

            override var description: String{

                return String(format: "%@, %@", self.lastName, self.firstName)
            }
        }

    // main.swift

        let stu1:Student = Student(firstName: "MingJie", lastName: "Li")
        let stu2:Student = Student(firstName: "LongHu", lastName: "Huang")
        let stu3:Student = Student(firstName: "LianJie", lastName: "Li")
        let stu4:Student = Student(firstName: "Jian", lastName: "Xiao")

        // 先按照姓进行排序
        let lastnNmeDesc:NSSortDescriptor = NSSortDescriptor(key: "lastName", ascending: true)

        // 再按照名进行排序
        let firstNameDesc:NSSortDescriptor = NSSortDescriptor(key: "firstName", ascending: true)

        // 1.按描述器排序，可变数组排序

            let array1 = NSMutableArray(objects: stu1, stu2, stu3, stu4)

            // 按顺序添加排序描
            let descs1 = NSArray(objects: lastnNmeDesc, firstNameDesc)

            array1.sortUsingDescriptors(descs1 as! [NSSortDescriptor])

            print(array1)

        // 2.按描述器排序，不可变数组排序

            let array2 = NSArray(objects: stu1, stu2, stu3, stu4)

            // 按顺序添加排序描
            let descs2 = NSArray(objects: lastnNmeDesc, firstNameDesc)

            let array3 = array2.sortedArrayUsingDescriptors(descs2 as! [NSSortDescriptor])

            print(array3)

微信关注我们

原文链接：https://yq.aliyun.com/articles/312161

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

iOS - Swift String 字符串

前言 public struct String public class NSString : NSObject, NSCopying, NSMutableCopying, NSSecureCoding Swift 语言主要使用 String 和 Character 来存储字符数据。String 是字符串类型，Character 是字符类型，一个或多个字符组成一个字符串。 String ： Swift 语言中的 String 类型与经典 Cocoa 或 Cocoa Touch 框架中的 Foundation NSString 类型进行了无缝衔接，Swift 语言中的 String 类型实现了 NSString 的大部分属性和方法，字符串搜索、拷贝、插入、删除等操作都有相应的 API 函数可以使用。 String 类型可以调用 NSString 类型的属性和方法，但是 NSString 类型不可以调用 String 类型独有的方法。并且以往框架中的任何要求使用 NSString 类型作为参数的函数，都可以使用 String 类型来替换，Swift 语言会自动将 String 类型转换为 ...

2016-08-16

443

前言 Set：集合 public struct Set<Element : Hashable> : Hashable, CollectionType, ArrayLiteralConvertible public class NSSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSFastEnumeration 集 NSSet 是一个无序对象的集合。集也有动态和静态之分，NSSet 是静态类型，成员不能被修改。NSMutableSet 是动态类型，成员可以被修改。集和数组不一样的是，它存储的每一个元素都是唯一的，没有完全相同的两个元素。所以数组中如果有两个相同的值，转换为集后只会有一个值。 NSCountedSet：计数集合 public class NSCountedSet : NSMutableSet NSCountedSet 这种集合中同一对象可以出现多次，然而并非在集合中存放多次这个对象，而是维护一个次数计数。当第一次将对象添加到集合中时，对象的 count 值被置为 1，然后每次将这个对象...

2016-08-16

420

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

iOS - Swift Array 数组

前言

1、Array 与 NSArray 的相互转换

2、数组的创建

3、数组的长度计算

4、数组位置的获取

5、数组元素的获取

6、数组下标的获取

7、数组的判断

8、数组元素的组合

9、数组元素的追加

10、数组元素的删除

11、数组元素的替换

12、数组元素的交换

13、数组元素的修改

14、数组元素的过滤

15、数组的遍历

16、数组的排序

iOS - Swift String 字符串

iOS - Swift Set 集合

相关文章

发表评论

资源下载

优质分享App

Spring

Rocky Linux

Sublime Text

欢迎您来访！

iOS - Swift Array 数组

前言

1、Array 与 NSArray 的相互转换

2、数组的 创建

3、数组的 长度计算

4、数组位置的 获取

5、数组元素的 获取

6、数组下标的 获取

7、数组的 判断

8、数组元素的组合

9、数组元素的 追加

10、数组元素的 删除

11、数组元素的 替换

12、数组元素的 交换

13、数组元素的 修改

14、数组元素的 过滤

15、数组的遍历

16、数组的排序

iOS - Swift String 字符串

iOS - Swift Set 集合

相关文章

发表评论

资源下载

优质分享App

Spring

Rocky Linux

Sublime Text

欢迎您来访！

2、数组的创建

3、数组的长度计算

4、数组位置的获取

5、数组元素的获取

6、数组下标的获取

7、数组的判断

9、数组元素的追加

10、数组元素的删除

11、数组元素的替换

12、数组元素的交换

13、数组元素的修改

14、数组元素的过滤