集合类（Objective-C & Swift）

2022-05-19 12:03:32

内容提要：

　　本文前两部分讲了Cocoa的集合类和Swift的集合类，其中Cocoa提供的集合类包括NSArray、NSMutableArray、NSDictionary、NSMutableDictionary、NSSet；Swift的集合类包括Array<SomeType>或[SomeType]、Set<SomeType>、Dictionary<KeyType, ValueType>。每个小类目是对应的集合类的用法。最后，本文讲解了Cocoa集合类的3种遍历方法。

正文内容：

一. Cocoa提供的集合类：NSArray、NSMutableArray、NSDictionary、NSMutableDictionary。

　　 NSArray用来存储对象的有序列表。NSArray类有2个限制：(a)只能存储Objective-C的对象，不能存储基础数据类型，如int、float、enum、struct等。(b)不能在NSArray中存储nil。

（1）可以在NSArray中放入任意类型的对象。如下所示给array里放入一个NSString对象、一个NSArray对象：

     NSString *aString = @"stringA";

     NSArray *aArray = @[@"A",@"B"];

     NSArray *array = [NSArray arrayWithObjects:aString,aArray, nil];

（2）NSArray 常用方法：

//创建数组：

NSArray *aArray = [NSArray arrayWithObjects:@"A",@"B",@"C",nil];  //结尾有nil

-(instancetype)initWithArray:(NSArray<ObjectType> *)array copyItems:(BOOL)flag;

//用字面量格式创建数组：

NSArray *aArray = @[@"A",@"B",@"C"];

//获取包涵的对象个数：

-(NSUInteger)count;

//获取索引处的对象：

-(id)objectAtIndex:(NSUInteger)index;

//获取一个object的索引（可以用于判断object是否存在于Array中）第一个方法只要值一致就可以了，第二个方法比较指针一致。

-(NSUInteger)indexOfObject:(ObjectType)anObject;

-(NSUInteger)indexOfObjectIdenticalTo:(ObjectType)anObject;

//通过字面量访问数组语法, 获取索引处的对象:

 id myObject = array[i];

//字符串切分成数组

NSString *string = @"top:bottom:left:right";

NSArray *array = [string componentsSeparatedByString:@":"];

//数组合并成字符串

string = [chuncks componentsJoinedByString:@"~"];//得到的字符串是：“top~bottom~left~right”

(3) 遍历数组

 NSArray *array = @[@"s1", @"s2", @"s3"];

// 使用快速枚举遍历数组

    for (NSString * string in array) {

        NSLog(@"%@", string);

    }

 //  使用代码块遍历数组

    [array enumerateObjectsUsingBlock:^(NSString *string, NSUInteger index, BOOL *stop){

        NSLog(@"%@", string);

    }];

　　快速枚举，执行操作要一项项地线性完成，代码块可以让循环操作并发执行。

（4）NSMutableArray

    //创建可变数组

    NSMutableArray *array = [NSMutableArray arrayWithCapacity:];//容量只是一个建议值,是为了让Cocoa能够对代码进行一些优化
    // 或用其它数组创建可变数组
    NSMutableArray *array1 = [NSMutableArray arrayWithArray:array0];

//在数组末尾添加对象：

    [array addObject:@"myGod"];

    //删除特定索引处的对象：

    [array removeObjectAtIndex:];//删除后，位于被删除对象后面的元素自动前移补缺

(5) NSDictionary、NSMutableDictionary

字典(也被称为散列表或关联数组)使用的是键查询的优化方式。它可以立即找出要查询的数据，而不需要遍历整个数组。

    NSObject *obj1, *obj2, *obj3;

    NSString *key1, *key2, *key3;

    // 创建字典

    NSDictionary *dictionary = [NSDictionary dictionaryWithObjectsAndKeys:obj1, key1, obj2, key2, obj3, key3, nil];

    //用字面量语法创建字典

    NSDictionary *dictionary1 = @{key1:obj1, key2:obj2, key3:obj3};

    //使用key访问数值

    NSObject *obj = [dictionary objectForKey:key1];

    // 使用字面量语法根据key访问数值

    NSObject *obj0 = dictionary[key1];

    // 创建可变字典

    NSMutableDictionary *mutableDictionary1 = [NSMutableDictionary dictionary];

    NSMutableDictionary *mutableDictionary2 = [NSMutableDictionary dictionaryWithCapacity:];

    //为字典添加元素

    [mutableDictionary1 setObject:obj1 forKey:key1];

    //删除元素

    [mutableDictionary1 removeObjectForKey:key1];

二. Swift中的集合类：Array<SomeType>或[SomeType]、Set<SomeType>、Dictionary<KeyType, ValueType>。

　　Swift语言中的数组和字典存储的数值类型必须明确。在后台，Swift 的数组和字典都是由泛型集合来实现的。

（1）数组： Array<SomeType>或[SomeType]

　　Objective-C 的 NSArray 和 NSMutableArray ，这两个类可以存储任意类型的对象，并且不提供所返回对象的任何特别信息。在 Swift 中，数据值在被存储进入某个数组之前类型必须明确，方法是通过显式的类型标注或类型推断，可以存储基础数据类型，如Int、Float等。比如Array<SomeType>这样的形式，其中SomeType是这个数组中唯一允许存在的数据类型。

// 创建数组

var sList: [String] = ["s1", "s2", "s3"]

var sList3:[String] = []

// 创建数组（类型推断）

var sList0 = ["s1", "s2", "s3"]

// 使用构造语法，创建数组

var someInts = [Int]()

// 使用构造语法，创建特定大小并且所有数据为默认值的数组

var threeDoubles = [Double](count: , repeatedValue:0.0)

// 使用构造语法，创建特定大小并且所有数据为默认值的数组（类型推断）

var anotherThreeDoubles = Array(count: , repeatedValue: 2.5)

// 数组中元素个数

print("The sList contains \(sList.count) items")

// 判断是否为空

if sList3.isEmpty {

    print("Empty")

}else {

    print("Not Empty")

}

// 在数组后面添加新元素

sList.append("s4")

//使用加法赋值运算符（+=）在数组后面添加1个或多个新元素

sList += ["s5"];

sList += ["s6", "s7", "s8"]

// 使用加号操作符组合两个数组

var sixDoubles = threeDoubles + anotherThreeDoubles

//使用下标语法来获取数组中的数据项

var a = sList[]

//使用下标语法改变对应数据

sList[] = "egg"

//使用下标改变一系列数值，个数有可能不同

sList[...] = ["egg", "egg"]//把2-7共5个值替换成了2个值

//插入

sList.insert("apple", atIndex: )

//移除，并返回移除的数值

let b = sList.removeAtIndex()

//移除最后一项

let last = sList.removeLast()

//移除所有，[]但不为nil
sList.removeAll()

//遍历数组

for item in sList{

    print(item)

}

（2）Set<SomeType>

Set用来存储相同类型并且没有确定顺序的值，Set中元素顺序不确定，Set中元素不重复。

//创建特定类型的空Set

var set0 = Set<Character>()

//Set中元素个数

print("letters is of type Set<Character> with \(set0.count) count")

//赋空值

set0 = []

//使用数组字面量来构造一个Set

var set: Set<String> = ["s1", "s2", "s3"]

//使用数组字面量来构造一个Set(类型推断)

var set1: Set = ["s1", "s2", "s3"]

//isEmpty

if set0.isEmpty {

    print("Empty")

}else {

    print("Not Empty")

}

//插入,添加一个新的元素

set0.insert("a")

//删除一个元素,返回nil或者返回被删除的元素

let cc = set0.remove("b")

//删除Set中所有值, Set变为空，但不为nil

set0.removeAll()

//遍历Set

for value in set1 {

    print("\(value)")

}

let a : Set = [, , , , ]

let b : Set = [, , , , ]

let c : Set = [, ]

//union 并集

a.union(b)

//intersect 交集

a.intersect(b)

//exclusiveOr 并集-交集

a.exclusiveOr(b)

//subtract a-b

a.subtract(b)

// “是否等”运算符(==)

a == c

//isSubsetOf 是否是子集

c.isSubsetOf(a)

//isSupersetOf 是否是父集

a.isSupersetOf(c)

//isStrictSubsetOf 是否是子集 并且不相等(但a == c却是true)

c.isSubsetOf(a)

//isStrictSupersetOf 是否是父集 并且不相等(但a == c却是true)

a.isSupersetOf(c)

// a和c没有一个相同的值则为true

a.isDisjointWith(c)

（3）Dictionary<KeyType, ValueType>

KeyType的唯一限制就是可哈希的，这样可以保证它是独一无二的，所有的 Swift 基本类型（例如String，Int， Double和Bool）都是默认可哈希的，并且所有这些类型都可以在字典中当做键使用。（PS：可哈希的，即该类型必须提供一个方法来计算它的哈希值，比如两个对象是否相等，会去比较两个对象的哈希值是否相等）。

let obj1 : String = "obj1", obj2 : String = "obj2", obj3 : String = "obj3"

let key1 : String = "key1", key2 : String  = "key2", key3 : String  = "key3"

//创建空字典

var aDictionary = Dictionary<Int, String>() //值为[:]

//赋值 和使用空字典字面量来 变为空字典

aDictionary[] = "Two"

aDictionary = [:]

//创建字典变量

var dictionary:[String: String] = [key1:obj1, key2:obj2, key3:obj3]

//创建字典变量（类型推断）

var dictionary1 = [key1:obj1, key2:obj2, key3:obj3]

//字典的数据项数量

print("The dictionary contains \(dictionary.count) items")

//isEmpty

if dictionary.isEmpty {

    print("Empty")

}else {

    print("Not Empty")

}

//使用下标语法, 添加新的数据项 或 修改老的数据项

dictionary["key4"] = "obj4"

dictionary["key1"] = "XX"

// 根据key 设置新的键值对 或 更新已有key的值

dictionary.updateValue("YY", forKey: "key1")

// updateValue返回值为 key所对应的value值 或者 nil

let oldValue = dictionary.updateValue("YY", forKey: "ke1")

// 下标语法返回值为 key所对应的value值 或者 nil

let value = dictionary["k1"]

// 下标语法 赋新值 或者 从字典里移除一个键值对

dictionary["key1"] = "XY"

dictionary["key1"] = nil

// 移除键值对 removeValue返回值为 key所对应的value值 或者 nil

let removeValue =  dictionary.removeValueForKey("key4")

//字典遍历

for (key, value) in dictionary {

    print("\(key):\(value)")

}

//字典遍历 keys

for key in dictionary.keys {

    print("\(key)")

}

//字典遍历 values

for value in dictionary.values {

    print("\(value)")

}

// 使用dictionary的keys或者values 创建新数组Array

let keysArray = Array(dictionary.keys)

let valueArray = Array(dictionary.values)

三. Cocoa中的集合类的遍历

（1）for循环

//Array

for (NSUInteger i = ; i < Array.count; i++) {

    id object = Array[i]

}

//Dictionary

NSArray *keys = [Dictionary allKeys];

for (NSUInteger i = ; i < keys.count; i++) {

    id key = keys[i];

    id object = [Dictionary objectForKey:key];

}

//Set

NSArray *tranArray = [Set allObjects];

//Then same with array

（2）Fast Enumeration

//Array, 反向遍历［array reverseObjectEnumerator]

for(id object in self.testArray){

}

//Dictionay

for(id key in self.testDic){

    id object = [self.testDic objectForKey:key];

}

//Set

for(id object in self.testSet) {

}

（3）Block Enumeration

优点：可以获取index，不用生成中间变量，方便实现反向遍历，对于比较耗时的任务实现并发遍历比较方便，提供停止遍历的变量。

//Array

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

}];

//Dictionary

[Dictionary enumerateKeysAndObjectsUsingBlock:^(id  _Nonnull key, id  _Nonnull obj, BOOL * _Nonnull stop) {

}];

//Set

[Set enumerateObjectsUsingBlock:^(id  _Nonnull obj, BOOL * _Nonnull stop) {

}];

//另一个block遍历方法，以Array为例，Dictionary和Set分别也实现了对应的方法。

//NSEnumerationOptions是一个枚举类型，

[Array enumerateObjectsWithOptions:(NSEnumerationOptions) usingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {

}];

typedef NS_OPTIONS(NSUInteger, NSEnumerationOptions) {

    NSEnumerationConcurrent = (1UL << ), //遍历的块并发执行

    NSEnumerationReverse = (1UL << ),    //反向遍历

};

码农公寓

相关文章