NSArray 数组

前言

  • NSArray:数组

    • Objective-C

      1
      2
      @interface NSArray<__covariant ObjectType> : NSObject <NSCopying, NSMutableCopying, NSSecureCoding, NSFastEnumeration>
      @interface NSMutableArray<ObjectType> : NSArray<ObjectType>
    • Swift

      1
      public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSFastEnumeration
    • 数组只能存储 OC 对象,不能存储 C 语言中的基本数据类型,也不能存储 nil。

    • Xcode 7 对系统中常用的一系列容器类型都增加了泛型支持(),有了泛型后就可以指定容器类中对象的类型了。假如向泛型容器中加入错误的对象,编译器会报警告。

      1
      2
      __covariant:协变性,子类型可以强转到父类型(里氏替换原则)。
      __contravariant:逆变性,父类型可以强转到子类型。
    • 不指定泛型类型的对象可以和任意泛型类型转化,但指定了泛型类型后,两个不同类型间是不可以强转的,假如你希望主动控制转化关系,就需要使用泛型的协变性和逆变性修饰符。

  • Array:数组

    • Swift

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

1、NSArray 不可变数组的创建

  • Objective-C

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    // 直接创建不可变数组
    /*
    数组成员是 id 类型,表示数组元素可以是任意的 oc 对象。
    */
    NSArray *arr1 = @[@"bei", @"jing", @"huan", @"ying", @"nin"];

    // 对象方法创建

    NSArray *arr2 = [[NSArray alloc] init];

    // 和 arr1 的地址不相同
    NSArray *arr3 = [[NSArray alloc] initWithArray:arr1];

    NSArray *arr4 = [[NSArray alloc] initWithObjects:@"bei", @"jing", @"huan", @"ying", @"nin", nil];

    // 类方法创建

    NSArray *arr5 = [NSArray array];

    // 和 arr1 的地址不相同
    NSArray *arr6 = [NSArray arrayWithArray:arr1];

    // 创建只有一个元素(id)的数组
    NSArray *arr7 = [NSArray arrayWithObject:@"qian"];

    NSArray *arr8 = [NSArray arrayWithObjects:@"bei", @"jing", @"huan", @"ying", @"nin", nil];

    // 从 文件 创建字符串
    NSString *path = [NSHomeDirectory() stringByAppendingString:@"/Desktop/test.txt"];

    NSArray *arr9 = [[NSArray alloc] initWithContentsOfFile:path];
    NSArray *arr10 = [NSArray arrayWithContentsOfFile:path];

    // 从 Url 创建字符串
    /*
    file:// 文件前缀
    */
    NSURL *url = [NSURL URLWithString:[@"file://" stringByAppendingString:[NSHomeDirectory()
    stringByAppendingString:@"/Desktop/test.txt"]]];

    NSArray *arr11 = [[NSArray alloc] initWithContentsOfURL:url];
    NSArray *arr12 = [NSArray arrayWithContentsOfURL:url];

    // 泛型定义

    // 指明数组中存放的是 NSString 类型数据
    NSArray<NSString *> *arr13 = @[@"bei", @"jing", @"huan", @"ying", @"nin"];

    // 指明数组中存放的是 NSNumber 类型数据
    NSArray<NSNumber *> *arr14 = @[@2, @4, @6, @8, @10];

2、NSArray/Array 数组成员个数计算

  • Objective-C

    1
    2
    3
    NSArray *arr = @[@"bei", @"jing", @"huan", @"ying", @"nin"];

    NSUInteger length = [arr count];
  • Swift

    1
    2
    3
    4
    5
    // Array 或 NSArray 型数组

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

    let length: Int = array.count

3、NSArray/Array 从数组中取成员

3.1 NSArray 从数组中取成员

  • Objective-C

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    NSArray *arr = @[@"bei", @"jing", @"huan", @"ying", @"nin"];

    // []
    NSArray *arr1 = arr[1];

    // objectAtIndex
    NSArray *arr2 = [arr objectAtIndex:2];

    // subarrayWithRange
    NSArray *arr3 = [arr subarrayWithRange:NSMakeRange(2, 2)];

    // for...in 循环
    /*
    取出数组中的每个元素,分别保存在 tmp 中
    */
    for (NSString *tmp in arr) {

    NSLog(@"%@", tmp);
    }

    // id (void *) 泛型指针, 取出数组中的每个元素,分别保存在 tmp 中
    for (id tmp in arr) {

    NSLog(@"tmp = %@", tmp);
    }
  • Swift

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    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 obj9 = nsArray.objectsAtIndexes(NSIndexSet(indexesInRange: NSMakeRange(2, 2)))

    // 获取数组指定范围内的元素
    let obj10 = nsArray.subarrayWithRange(NSMakeRange(2, 3))

3.2 Array 从数组中取成员

  • Swift

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    let array: Array = ["bei", "jing", "huan", "ying", "ni"]

    // 获取数组指定下标的元素
    let obj1: String = array[1]

    // 获取数组的第一个元素
    let obj2: String? = array.first

    // 获取数组指定范围内的元素
    let obj4 = array[2...4]

4、NSArray/Array 取数组中最后一个元素

4.1 NSArray 取数组中最后一个元素

  • Objective-C

    1
    2
    3
    4
    5
    NSArray *arr = @[@"bei", @"jing", @"huan", @"ying", @"nin"];

    id lastObject1 = [arr lastObject];

    id lastObject2 = arr[[arr count]-1];
  • Swift

    1
    2
    3
    4
    let nsArray: NSArray = ["bei", "jing", "huan", "ying", "ni"]

    // 获取数组的最后一个元素
    let obj8: String = nsArray.lastObject as! String

4.2 Array 取数组中最后一个元素

  • Swift

    1
    2
    3
    4
    let array: Array = ["bei", "jing", "huan", "ying", "ni"]

    // 获取数组的最后一个元素
    let obj3: String? = array.last

5、NSArray/Array 由元素的值获取下标

5.1 NSArray 由元素的值获取下标

  • Objective-C

    1
    2
    3
    NSArray *arr = @[@"bei", @"jing", @"huan", @"ying", @"nin"];

    NSUInteger index = [arr indexOfObject:@"huan"];
  • Swift

    1
    2
    3
    4
    let nsArray: NSArray = ["bei", "jing", "huan", "ying", "ni"]

    // 获取指定元素的下标,若元素不存在,返回 Int.max
    let indexNum2: Int = nsArray.indexOfObject("hun")

5.2 Array 由元素的值获取下标

  • Swift

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    let array: Array = ["bei", "jing", "huan", "ying", "ni"]

    // 获取指定元素的下标,若元素不存在,返回 nil
    let indexNum1: Int? = array.indexOf("huan")

    // 获取起始位置,即 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()

6、NSArray/Array 判断数组中是否包含某个元素

6.1 NSArray 判断数组中是否包含某个元素

  • Objective-C

    1
    2
    3
    NSArray *arr = @[@"bei", @"jing", @"huan", @"ying", @"nin"];

    BOOL result = [arr containsObject:@"huan"];
  • Swift

    1
    2
    3
    4
    5
    let nsArr1: NSArray = [2, 3, 5, 8]
    let nsArr2: NSArray = [1, 4, 7, 9]

    // 返回两个数组中第一个相同的元素,没有时返回 nil
    let firstObj: AnyObject? = nsArr1.firstObjectCommonWithArray(nsArr2 as [AnyObject])

6.2 Array 判断数组中是否包含某个元素

  • Swift

    1
    2
    3
    4
    let arr1: Array = [1, 3, 5, 8]

    // 判断数组中是否存在指定的元素
    let bl3: Bool = arr1.contains(55)

7、NSArray/Array 数组的比较

7.1 NSArray 数组的比较

  • Objective-C

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    NSArray *arr1 = @[@"bei", @"jing", @"huan", @"ying", @"nin"];
    NSArray *arr2 = @[@"ni", @"hao", @"bei", @"jing"];

    // isEqualToArray

    // 比较两个数组内容是否相同
    BOOL bl = [arr1 isEqualToArray:arr2];

    // firstObjectCommonWithArray

    // 返回两个数组中第一个相同的元素
    NSString *str = [arr1 firstObjectCommonWithArray:arr2];
  • Swift

    1
    2
    3
    4
    5
    6
    7
    8
    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)

7.2 Array 数组的比较

  • Swift

    1
    2
    3
    4
    5
    6
    7
    8
    let arr1: Array = [1, 3, 5, 8]
    let arr2: Array = [1, 3, 7, 8]

    // 判断两个数组是否相等
    let bl1: Bool = arr1 == arr2

    // 判断数组是否为空
    let bl2: Bool = arr1.isEmpty

8、NSArray 数组组合

  • Objective-C

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    NSArray *arr1 = @[@"bei", @"jing", @"huan", @"ying", @"nin"];
    NSArray *arr2 = @[@"Users", @"JHQ0228", @"Desktop"];

    // 按指定字符组合
    NSString *str1 = [arr1 componentsJoinedByString:@" "];

    // 按路径组合
    /*
    将数组中的元素自动组合成路径,在每个元素之间自动加上 “/”
    */
    NSString *str2 = [NSString pathWithComponents:arr2];
  • Swift

    1
    2
    3
    4
    5
    6
    7
    8
    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、NSMutableArray/Array 可变数组的创建

9.1 NSMutableArray 可变数组的创建

  • Objective-C

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    // 对象方法创建
    /*
    创建指定长度的数组,预先分配空间,提高效率,实际长度可大于指定长度
    */
    NSMutableArray *arr1 = [[NSMutableArray alloc] initWithCapacity:0];

    // 类方法创建
    /*
    创建指定长度的数组,预先分配空间,提高效率,实际长度可大于指定长度
    */
    NSMutableArray *arr2 = [NSMutableArray arrayWithCapacity:0];
  • Swift

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    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"))

9.2 Array 数组的创建

  • Swift

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    // 不赋初值,指定数组内数据为 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]]

10、NSMutableArray/Array 数组元素的添加

10.1 NSMutableArray 数组元素的添加

  • Objective-C

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    NSMutableArray *arr = [NSMutableArray arrayWithCapacity:0];

    // addObject

    // 向数组中追加一个元素
    [arr addObject:@"bei"];

    // addObjectsFromArray

    // 追加数组
    NSArray *arrAdd = @[@"dian", @"ying", @"xue", @"yuan"];
    [arr addObjectsFromArray:arrAdd];

    // insertObject... atIndex

    // 在数组中任意位置插入一个元素
    [arr insertObject:@"hao" atIndex:2];

    // arrayByAddingObject

    // 向数组添加一个元素,返回一个新的数组
    NSArray *arr1 = [arr arrayByAddingObject:@"ma"];
  • Swift

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    let nsArray: NSMutableArray = ["jing", "huan"]

    // 向数组添加一个元素,返回一个新的数组
    let nsArray1 = nsArray.arrayByAddingObject("ma")

    // 在数组末尾追加一个元素
    nsArray.addObject("ni")

    // 在数组末尾追加一个数组
    nsArray.addObjectsFromArray(["ni", "hao"])

    // 在指定位置追加一个元素
    nsArray.insertObject("bei", atIndex: 0)

10.2 Array 数组元素的添加

  • Swift

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    var arr1: Array = ["bei", "jing"]

    // 使用 "+" 号连接两个数组
    let arr2 = arr1 + ["huan", "ying", "ni"]

    // 在数组末尾追加一个元素
    arr1.append("hao")

    // 在指定位置插入一个元素
    arr1.insert("ni", atIndex: 2)

11、NSMutableArray/Array 数组元素的删除

11.1 NSMutableArray 数组元素的删除

  • Objective-C

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    NSMutableArray *arr = [NSMutableArray arrayWithObjects:@"nan", @"jing", @"huan", @"ying", 
    @"nin", @"bei", @"jing", @"ni", @"hao", nil];

    // 删除指定下标的元素
    [arr removeObjectAtIndex:2];

    // 删除指定元素,删除所有指定元素
    [arr removeObject:@"ying"];

    // 删除指定元素
    [arr removeObjectIdenticalTo:@"nan"];

    // 删除指定范围的元素
    NSRange range = {2,1};
    [arr removeObjectsInRange:range];

    // 删除最后一个元素
    [arr removeLastObject];

    // 删除所有元素
    [arr removeAllObjects];
  • Swift

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    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.2 Array 数组元素的删除

  • Swift

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    var arr1: Array = ["bei", "jing", "huan", "ying", "ni"]

    // 删除指定位置的数组元素
    arr1.removeAtIndex(3)

    // 删除数组中的最后一个元素
    arr1.removeLast()

    // 删除指定范围内的数组元素
    arr1.removeRange(0...1)

    // 删除所有数组元素
    arr1.removeAll(keepCapacity: true)

12、NSMutableArray 数组元素的替换

  • Objective-C

    1
    2
    3
    4
    NSMutableArray *arr = [NSMutableArray arrayWithObjects:@"nan", @"jing", @"hao", nil];

    // 替换指定下标元素
    [arr replaceObjectAtIndex:1 withObject:@"ren"];
  • Swift

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    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))

13、NSMutableArray 数组元素的交换

  • Objective-C

    1
    2
    3
    NSMutableArray *arr = [NSMutableArray arrayWithObjects:@"bei", @"jing", @"nin", @"hao", nil];

    [arr exchangeObjectAtIndex:0 withObjectAtIndex:1];
  • Swift

    1
    2
    3
    let nsArr: NSMutableArray = ["bei", "jing", "huan", "ying", "nin"]

    nsArr.exchangeObjectAtIndex(2, withObjectAtIndex: 4)

14、NSMutableArray/Array 数组元素的修改

14.1 NSMutableArray 数组元素的修改

  • Objective-C

    1
    2
    3
    4
    5
    6
    7
    NSMutableArray *arr = [NSMutableArray arrayWithObjects:@"bei", @"jing", @"nin", @"hao", nil];

    // 修改整个数组(覆盖重写)
    [arr setArray:@[@"bei", @"jing", @"huan", @"ying", @"nin"]];

    // 修改数组中的某个元素
    arr[3] = @"huan";
  • Swift

    1
    2
    3
    4
    5
    6
    7
    let nsArr: NSMutableArray = ["bei", "jing", "huan", "ying", "nin"]

    // 修改数组中的某个元素
    nsArr[4] = "ni"

    // 修改整个数组(覆盖重写)
    nsArr.setArray(["ni", "hao"])

14.2 Array 数组元素的修改

  • Swift

    1
    2
    3
    var arr: Array = ["bei", "jing", "huan", "ying", "ni"]

    arr[0] = "nan"

15、NSMutableArray 给数组里的所有元素发送一个消息

  • Objective-C

    1
    2
    3
    4
    5
    6
    7
    8
    Student *stu1 = [[Student alloc] init];
    Student *stu2 = [[Student alloc] init];
    Student *stu3 = [[Student alloc] init];

    NSArray *arr = [NSArray arrayWithObjects:stu1, stu2, stu3, nil];

    // 发送消息
    [arr makeObjectsPerformSelector:@selector(studentTest)];

16、NSMutableArray/Array 数组元素的过滤

16.1 NSMutableArray 数组元素的过滤

  • Swift

    1
    2
    3
    4
    5
    6
    7
    let nsArr: NSMutableArray = [1, 9, 2, 8, 45]

    let nsArray: [AnyObject] = nsArr.filter { (obj:AnyObject) -> Bool in

    // 过滤掉不能被 3 整除的数
    return (obj as! Int) % 3 == 0
    }

16.2 Array 数组元素的过滤

  • Swift

    1
    2
    3
    4
    5
    6
    7
    let arr: Array = [1, 9, 2, 8, 45]

    let array: [Int] = arr.filter { (obj:Int) -> Bool in

    // 过滤掉不能被 3 整除的数
    return obj % 3 == 0
    }

17、NSMutableArray/Array 数组的遍历

17.1 NSMutableArray 数组的遍历

  • 用 for 循环遍历

    • Objective-C

      1
      2
      3
      4
      5
      6
      NSArray * array = [NSArray arrayWithObjects:@"bei", @"jing", @"huan", @"ying", @"nin", nil];

      for (int i = 0; i < [array count]; i ++) {

      NSLog(@"%@", array[i]);
      }
  • 用 for…in 循环遍历

    • Objective-C

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      NSArray *array = [NSArray arrayWithObjects:@"bei", @"jing", @"huan", @"ying", @"nin", nil];

      // id (void *) 泛型指针, 取出数组中的每个元素,分别保存在 tmp 中
      for (id tmp in array) {

      NSLog(@"%@", tmp);
      }

      // 取出数组中的每个元素,分别保存在 tmp 中
      for (NSString *tmp in array) {

      NSLog(@"%@", tmp);
      }
    • Swift

      1
      2
      3
      4
      5
      6
      7
      let arr = ["bei", "jing", "huan", "ying", "ni"]

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

      print(tmp)
      }
  • 用 block(闭包)循环遍历

    • Objective-C

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      NSArray *array = [NSArray arrayWithObjects:@"bei", @"jing", @"huan", @"ying", @"nin", nil];

      [array enumerateObjectsUsingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {

      // obj == array[i],idx == i
      NSLog(@"%@", obj);

      if ([obj isEqual: @"huan"]) {

      // 停止遍历
      *stop = YES;
      }
      }];
    • Swift

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      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)
      }
      }
  • 用迭代器遍历

    • Objective-C

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      NSArray *array = [NSArray arrayWithObjects:@"bei", @"jing", @"huan", @"ying", @"nin", nil];

      // 获取数组的正序迭代器
      NSEnumerator *enu1 = [array objectEnumerator];

      // 获取数组的反序迭代器
      NSEnumerator *enu2 = [array reverseObjectEnumerator];

      id obj = nil;

      // 正序,获取下一个需要遍历的元素
      while (obj = [enu1 nextObject]) {

      NSLog(@"%@", obj);
      }

      // 反序,获取下一个需要遍历的元素
      while (obj = [enu2 nextObject]) {

      NSLog(@"%@", obj);
      }
    • Swift

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      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)
      }
  • 条件遍历

    • Objective-C

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      // 1.indexesOfObjectsPassingTest

      NSArray *array = [NSArray arrayWithObjects:@3, @8, @17, @2, @25, @6, @89, nil];

      NSIndexSet *indexSet = [array indexesOfObjectsPassingTest:^BOOL(id _Nonnull obj,
      NSUInteger idx,
      BOOL * _Nonnull stop) {

      // 遍历数组,找出数组中所有大于 10 的元素的位置
      return [obj intValue] > 10 ? : NO;
      }];

      [indexSet enumerateIndexesUsingBlock:^(NSUInteger idx, BOOL * _Nonnull stop) {

      // 输出所有大于 10 的元素值
      NSLog(@"%@", array[idx]);
      }];

      // 2.indexOfObjectPassingTest

      NSUInteger index = [array indexOfObjectPassingTest:^BOOL(id _Nonnull obj,
      NSUInteger idx,
      BOOL * _Nonnull stop) {

      // 遍历数组,找出数组中第一个大于 10 的元素的位置
      return [obj intValue] > 10 ? : NO;
      }];

      // 输出第一个大于 10 的元素值
      NSLog(@"%@", array[index]);
    • Swift

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      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)

17.2 Array 数组的遍历

  • 用 for…in 循环遍历

    • Swift

      1
      2
      3
      4
      5
      6
      7
      let arr = ["bei", "jing", "huan", "ying", "ni"]

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

      print(tmp)
      }

18、NSMutableArray/Array 数组排序

18.1 NSMutableArray 数组排序

  • 冒泡排序

    • Objective-C

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      NSMutableArray *arr = [NSMutableArray arrayWithObjects:@"sunday", @"sunny", @"summer", @"sun", nil];

      for (int i = 0; i < [arr count] - 1; i++) {
      for (int j = 0; j < [arr count] - 1 - i; j++) {

      // 大小判断 arr[j] > arr[j + 1]
      if ([arr[j] compare:arr[j + 1]] == NSOrderedDescending) {

      // 位置交换
      [arr exchangeObjectAtIndex:j withObjectAtIndex:(j + 1)];
      }
      }
      }
    • Swift

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      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)
  • 用指定的方法排序

    • Objective-C

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      91
      92
      93
      94
      95
      96
      97
      98
      99
      100
      101
      102
      103
      // 1.用指定的方法排序,可变数组排序

      NSMutableArray *arr1 = [NSMutableArray arrayWithObjects:@"sunday", @"sunny", @"summer", @"sun", nil];

      // 原数组的顺序改变,指定元素的比较方法:compare:,默认排序方式为升序排列
      [arr1 sortUsingSelector:@selector(compare:)];

      // 使排序结果 降序 排列
      NSEnumerator *enu = [arr1 reverseObjectEnumerator];

      id obj = nil;
      while (obj = [enu nextObject]) {

      // 排序后的结果为降序
      NSLog(@"%@", obj);
      }

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

      NSArray *arr2 = [NSArray arrayWithObjects:@"sunday", @"sunny", @"summer", @"sun", nil];

      // 返回一个排好的数组,原数组的顺序不变,指定元素的比较方法:compare:
      NSArray *arr3 = [arr2 sortedArrayUsingSelector:@selector(compare:)];

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

      // People.h

      #import <Foundation/Foundation.h>

      @interface People : NSObject

      // 名
      @property (nonatomic, retain) NSString *firstname;

      // 姓
      @property (nonatomic, retain) NSString *lastname;

      + (id)peopleWithFirstname:(NSString *)firstname lastname:(NSString *)lastname;

      // 返回值类型为 NSComparisonResult
      - (NSComparisonResult)comparePeople:(People *)peop;

      @end

      // People.m

      #import "People.h"

      @implementation People

      + (id)peopleWithFirstname:(NSString *)firstname lastname:(NSString *)lastname {
      People * peop = [[People alloc] init];

      peop.lastname = lastname;
      peop.firstname = firstname;

      return peop;
      }

      - (NSComparisonResult)comparePeople:(People *)peop {

      // 先按照姓排序
      NSComparisonResult result = [self.lastname compare: peop.lastname];

      if (result == NSOrderedSame) {

      // 如果有相同的姓,就比较名字
      result = [self.firstname compare: peop.firstname];
      }

      return result;
      }

      -(NSString *)description{

      return [NSString stringWithFormat:@"%@ %@", self.firstname, self.lastname];
      }

      @end

      // main.m

      #import "People.h"

      People *peop1 = [People peopleWithFirstname:@"MingJie" lastname:@"Li"];
      People *peop2 = [People peopleWithFirstname:@"LongHu" lastname:@"Huang"];
      People *peop3 = [People peopleWithFirstname:@"LianJie" lastname:@"Li"];
      People *peop4 = [People peopleWithFirstname:@"Jian" lastname:@"Xiao"];

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

      NSMutableArray *array1 = [NSMutableArray arrayWithObjects:peop1, peop2, peop3, peop4, nil];

      // 原数组的顺序改变
      [array1 sortUsingSelector:@selector(comparePeople:)];

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

      NSArray *array2 = [NSArray arrayWithObjects:peop1, peop2, peop3, peop4, nil];

      // 返回一个排好的数组,原数组的顺序不变
      NSArray *array3 = [array2 sortedArrayUsingSelector:@selector(comparePeople:)];
    • Swift

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      // 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)
  • 用 Block(闭包)排序

    • Objective-C

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      91
      92
      93
      94
      95
      96
      97
      98
      99
      100
      101
      102
      103
      104
      105
      106
      107
      108
      109
      110
      111
      112
      // 1.利用 block 进行排序,可变数组排序

      NSMutableArray *arr1 = [NSMutableArray arrayWithObjects:@"sunday", @"sunny", @"summer", @"sun", nil];

      [arr1 sortUsingComparator:^NSComparisonResult(id _Nonnull obj1, id _Nonnull obj2) {

      // 指定比较的方法,两个元素值比较
      NSComparisonResult result = [obj1 compare:obj2];

      // 返回比较的结果
      return result;
      }];

      // 2.利用 block 进行排序,不可变数组排序

      NSArray *arr2 = [NSArray arrayWithObjects:@"sunday", @"sunny", @"summer", @"sun", nil];

      // 返回一个排好的数组
      NSArray *arr3 = [arr2 sortedArrayUsingComparator:^NSComparisonResult(id _Nonnull obj1, id _Nonnull obj2) {

      // 指定比较的方法,两个元素值比较
      NSComparisonResult result = [obj1 compare:obj2];

      // 返回比较的结果
      return result;
      }];

      // 3.利用 block 进行排序,自定义类

      // People1.h

      #import <Foundation/Foundation.h>

      @interface People1 : NSObject

      // 名
      @property (nonatomic, retain) NSString *firstname;

      // 姓
      @property (nonatomic, retain) NSString *lastname;

      + (id)peopleWithFirstname:(NSString *)firstname lastname:(NSString *)lastname;

      @end

      // People1.m

      #import "People1.h”

      @implementation People1

      + (id)peopleWithFirstname:(NSString *)firstname lastname:(NSString *)lastname {
      People1 * peop = [[People1 alloc] init];

      peop.lastname = lastname;
      peop.firstname = firstname;

      return peop;
      }

      -(NSString *)description{

      return [NSString stringWithFormat:@"%@ %@", self.firstname, self.lastname];
      }

      @end

      // main.m

      #import "People1.h”

      People1 *peop1 = [People1 peopleWithFirstname:@"MingJie" lastname:@"Li"];
      People1 *peop2 = [People1 peopleWithFirstname:@"LongHu" lastname:@"Huang"];
      People1 *peop3 = [People1 peopleWithFirstname:@"LianJie" lastname:@"Li"];
      People1 *peop4 = [People1 peopleWithFirstname:@"Jian" lastname:@"Xiao"];

      // 1.利用 block 进行排序,可变数组排序

      NSMutableArray *array1 = [NSMutableArray arrayWithObjects:peop1, peop2, peop3, peop4, nil];

      [array1 sortUsingComparator:^NSComparisonResult(People1 * _Nonnull obj1, People1 * _Nonnull obj2) {

      // 先按照姓排序
      NSComparisonResult result = [obj1.lastname compare:obj2.lastname];

      if (result == NSOrderedSame) {

      // 如果有相同的姓,就比较名字
      result = [obj1.firstname compare:obj2.firstname];
      }

      return result;
      }];

      // 2.利用 block 进行排序,不可变数组排序

      NSArray *array2 = [NSArray arrayWithObjects:peop1, peop2, peop3, peop4, nil];

      NSArray *array3 = [array2 sortedArrayUsingComparator:^NSComparisonResult(People1 * _Nonnull obj1,
      People1 * _Nonnull obj2) {

      // 先按照姓排序
      NSComparisonResult result = [obj1.lastname compare:obj2.lastname];

      if (result == NSOrderedSame) {

      // 如果有相同的姓,就比较名字
      result = [obj1.firstname compare:obj2.firstname];
      }

      return result;
      }];
    • Swift

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      // 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)
  • 按描述器排序

    • Objective-C

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      91
      92
      93
      94
      95
      96
      97
      98
      99
      100
      101
      102
      103
      104
      105
      106
      107
      108
      109
      110
      //  Book.h

      #import <Foundation/Foundation.h>

      @interface Book : NSObject

      @property (nonatomic, retain) NSString *name;

      + (id)bookWithName:(NSString *)name;

      @end

      // Book.m

      #import "Book.h"

      @implementation Book

      + (id)bookWithName:(NSString *)name {
      Book *book = [[Book alloc] init];
      book.name = name;
      return book;
      }

      @end

      // People2.h

      #import <Foundation/Foundation.h>

      @class Book;

      @interface People2 : NSObject

      // 名
      @property (nonatomic, retain) NSString *firstname;

      // 姓
      @property (nonatomic, retain) NSString *lastname;

      // 书
      @property (nonatomic, retain) Book *book;

      + (id)peopleWithFirstname:(NSString *)firstname lastname:(NSString *)lastname bookName:(NSString *)bookName;

      @end

      // People2.m

      #import "People2.h"
      #import "Book.h"

      @implementation People2

      + (id)peopleWithFirstname:(NSString *)firstname lastname:(NSString *)lastname bookName:(NSString *)bookName {

      People2 *peop = [[People2 alloc] init];

      peop.lastname = lastname;
      peop.firstname = firstname;
      peop.book = [Book bookWithName:bookName];

      return peop;
      }

      - (NSString *)description{

      return [NSString stringWithFormat:@"%@ %@, bookName: %@", self.firstname, self.lastname, self.book.name];
      }

      @end

      // main.m

      #import "People2.h"

      People2 *peop1 = [People2 peopleWithFirstname:@"MingJie" lastname:@"Li" bookName:@"book1"];
      People2 *peop2 = [People2 peopleWithFirstname:@"LongHu" lastname:@"Huang" bookName:@"book2"];
      People2 *peop3 = [People2 peopleWithFirstname:@"LianJie" lastname:@"Li" bookName:@"book2"];
      People2 *peop4 = [People2 peopleWithFirstname:@"Jian" lastname:@"Xiao" bookName:@"book1"];

      // 先按照书名进行排序
      /*
      这里的 key 写的是 @property 的名称
      */
      NSSortDescriptor *bookNameDesc = [NSSortDescriptor sortDescriptorWithKey:@"book.name" ascending:YES];

      // 再按照姓进行排序
      NSSortDescriptor *lastnameDesc = [NSSortDescriptor sortDescriptorWithKey:@"lastname" ascending:YES];

      // 再按照名进行排序
      NSSortDescriptor *firstnameDesc = [NSSortDescriptor sortDescriptorWithKey:@"firstname" ascending:YES];

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

      NSMutableArray *array1 = [NSMutableArray arrayWithObjects:peop1, peop2, peop3, peop4, nil];

      // 按顺序添加排序描述器
      NSMutableArray *descs1 = [NSMutableArray arrayWithObjects:bookNameDesc, lastnameDesc, firstnameDesc, nil];

      [array1 sortUsingDescriptors:descs1];

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

      NSArray *array2 = [NSArray arrayWithObjects:peop1, peop2, peop3, peop4, nil];

      // 按顺序添加排序描述器
      NSArray *descs2 = [NSArray arrayWithObjects:bookNameDesc, lastnameDesc, firstnameDesc, nil];

      NSArray *array3 = [array2 sortedArrayUsingDescriptors:descs2];
    • Swift

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      // 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)

18.2 Array 数组排序

  • 用闭包排序

    • Swift

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      // 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)
  • 用指定的方法排序

    • Swift

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      // 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)

19、Array 与 NSArray 的相互转换

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

19.1 Array 转 NSArray

  • Swift

    1
    2
    3
    4
    5
    // Array 转换成 NSArray<AnyObject> 型
    let nsArray1: NSArray = array

    // Array 转换成 NSArray<AnyObject> 型
    let nsArray2: NSArray = array as NSArray

19.2 NSArray 转 Array

  • Swift

    1
    2
    3
    4
    5
    6
    7
    8
    // 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]
文章目录
  1. 1. 前言
  2. 2. 1、NSArray 不可变数组的创建
  3. 3. 2、NSArray/Array 数组成员个数计算
  4. 4. 3、NSArray/Array 从数组中取成员
    1. 4.1. 3.1 NSArray 从数组中取成员
    2. 4.2. 3.2 Array 从数组中取成员
  5. 5. 4、NSArray/Array 取数组中最后一个元素
    1. 5.1. 4.1 NSArray 取数组中最后一个元素
    2. 5.2. 4.2 Array 取数组中最后一个元素
  6. 6. 5、NSArray/Array 由元素的值获取下标
    1. 6.1. 5.1 NSArray 由元素的值获取下标
    2. 6.2. 5.2 Array 由元素的值获取下标
  7. 7. 6、NSArray/Array 判断数组中是否包含某个元素
    1. 7.1. 6.1 NSArray 判断数组中是否包含某个元素
    2. 7.2. 6.2 Array 判断数组中是否包含某个元素
  8. 8. 7、NSArray/Array 数组的比较
    1. 8.1. 7.1 NSArray 数组的比较
    2. 8.2. 7.2 Array 数组的比较
  9. 9. 8、NSArray 数组组合
  10. 10. 9、NSMutableArray/Array 可变数组的创建
    1. 10.1. 9.1 NSMutableArray 可变数组的创建
    2. 10.2. 9.2 Array 数组的创建
  11. 11. 10、NSMutableArray/Array 数组元素的添加
    1. 11.1. 10.1 NSMutableArray 数组元素的添加
    2. 11.2. 10.2 Array 数组元素的添加
  12. 12. 11、NSMutableArray/Array 数组元素的删除
    1. 12.1. 11.1 NSMutableArray 数组元素的删除
    2. 12.2. 11.2 Array 数组元素的删除
  13. 13. 12、NSMutableArray 数组元素的替换
  14. 14. 13、NSMutableArray 数组元素的交换
  15. 15. 14、NSMutableArray/Array 数组元素的修改
    1. 15.1. 14.1 NSMutableArray 数组元素的修改
    2. 15.2. 14.2 Array 数组元素的修改
  16. 16. 15、NSMutableArray 给数组里的所有元素发送一个消息
  17. 17. 16、NSMutableArray/Array 数组元素的过滤
    1. 17.1. 16.1 NSMutableArray 数组元素的过滤
    2. 17.2. 16.2 Array 数组元素的过滤
  18. 18. 17、NSMutableArray/Array 数组的遍历
    1. 18.1. 17.1 NSMutableArray 数组的遍历
    2. 18.2. 17.2 Array 数组的遍历
  19. 19. 18、NSMutableArray/Array 数组排序
    1. 19.1. 18.1 NSMutableArray 数组排序
    2. 19.2. 18.2 Array 数组排序
  20. 20. 19、Array 与 NSArray 的相互转换
    1. 20.1. 19.1 Array 转 NSArray
    2. 20.2. 19.2 NSArray 转 Array
隐藏目录