前言

    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)

iOS - Swift Array 数组

前言

1、Array 与 NSArray 的相互转换

2、数组的创建

3、数组的长度计算

4、数组位置的获取

5、数组元素的获取

6、数组下标的获取

7、数组的判断

8、数组元素的组合

9、数组元素的追加

10、数组元素的删除

11、数组元素的替换

12、数组元素的交换

13、数组元素的修改

14、数组元素的过滤

15、数组的遍历

16、数组的排序

热门文章

最新文章

相关课程

相关电子书

iOS - Swift Array 数组

前言

1、Array 与 NSArray 的相互转换

2、数组的 创建

3、数组的 长度计算

4、数组位置的 获取

5、数组元素的 获取

6、数组下标的 获取

7、数组的 判断

8、数组元素的组合

9、数组元素的 追加

10、数组元素的 删除

11、数组元素的 替换

12、数组元素的 交换

13、数组元素的 修改

14、数组元素的 过滤

15、数组的遍历

16、数组的排序

热门文章

最新文章

相关课程

相关电子书

2、数组的创建

3、数组的长度计算

4、数组位置的获取

5、数组元素的获取

6、数组下标的获取

7、数组的判断

9、数组元素的追加

10、数组元素的删除

11、数组元素的替换

12、数组元素的交换

13、数组元素的修改

14、数组元素的过滤