目录
一、字符串（NSString与NSMutableString）
2.3 日历（NSCalendar）与日期组件（NSDateComponents）
3.2 NSCopying和NSmutableCopying协议
七、有序集合（NSOrderedSet和NSMutableOrderedSet）
八、字典（NSDictionary和NSMutableDictionary）
一、字符串（NSString与NSMutableString）
NSString代表字符序列不可变的字符串，而NSMutable代表字符序列可变的字符串。
1.1 NSString字符串及功能
通过NSString，我们可以：
1、创建字符串。2、读取文件或网络URL来初始化字符串，或者将字符串写入文件或URL。3、获取字符串长度，即可获取字符串字符个数，也可获取字符串包括的字节个数。4、获取字符串中的字符或字节，即可获取指定位置的字符，也可获取指定范围的字符。5、获取字符串对应的C风格字符串。6、连接、分隔、查找、替换、比较字符串。7、对字符串中的字符进行大小写转换。
以下用代码来展示如上的功能：
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
//使用Unicode数值数组初始化字符串
unichar data[6] = {97,98,99,100,101,102};
NSString *str1 = [[NSString alloc] initWithCharacters: data length: 6];
NSLog(@"%@",str1);
//将C风格的字符串转换为NSString对象
char *cstr = "Hello,iOS!";
NSString *str2 = [NSString stringWithUTF8String: cstr];
NSLog(@"%@",str2);
//将字符串写入指定对象
[str2 writeToFile: @"myFile.txt" atomically:YES encoding:NSUTF8StringEncoding error: nil];
//读取文件内容，用文件内容初始化字符串
NSString *str3 = [NSString stringWithContentsOfFile:@"NSStringTest.m"encoding:NSUTF8StringEncoding error:nil];
NSLog(@"%@",str3);
}
return 0;
}上面的代码还定义了一个unichar数组，该数组也是一个基本类型，就是unsigned short的别名。
程序将str2字符串的内容写入了底层的myFile.txt文件，因此，运行此程序就会发现该文件的运行目录下多了一个myFile.txt文件，该文件内容就是str2的字符串。
以上代码的运行结果为：
接下来我们再用一段代码来演示NSString的其他功能：
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSString *str1 = @"Hello";
NSString *str2 = @"Hello";
NSString *book = @"《疯狂iOS》";
//追加字符串
str1 = [str1 stringByAppendingString: @",iOS!"];
NSLog(@"str1后接“，iOS”得到的字符串：%@",str1);
str2 = [str2 stringByAppendingString: book];
NSLog(@"str2后接book得到的字符串：%@",str2);
//获取C风格的字符串
const char *cstr = [str1 UTF8String];
NSLog(@"获取的C字符串：%s",cstr);
str1 = [str1 stringByAppendingFormat: @"%@是一本非常不错的书",book];
NSLog(@"%@",str1);
//获取指定字符
NSString *s1 = [str1 substringToIndex: 5];
NSLog(@"s1前5个字符组成的字符串：%@",s1);
NSString *s2 = [str1 substringFromIndex: 10];
NSLog(@"获取str1从第10个字符开始以后的所有字符：%@",s2);
NSString *s3 = [str1 substringWithRange: NSMakeRange(5,10)];
NSLog(@"获取str1中第5个到第10个字符：%@",s3);
NSRange pos = [str1 rangeOfString: @"iOS"];
NSLog(@"iOS在str1中出现的开始位置：%ld,长度为：%ld",pos.location,pos.length);
//对字符进行大小转换
str1 = [str1 uppercaseString];
NSLog(@"str1的字符转化为大写：%@",str1);
//获取字符串长度和字节数
NSLog(@"str1的字符个数为：%lu",[str1 length]);
NSLog(@"str1按UTF-8解码后字节数为：%lu",[str1 lengthOfBytesUsingEncoding: NSUTF8StringEncoding]);
}
return 0;
}
上面的代码使用了一个NSRange类型的变量，NSRange并不是一个类，它只是一个结构体，包括了location和length两个unsigned int整型值，分别代表起始位置和长度。
还有一个NSMakeRange(loc，len)，它是一个结构体类型，包含两个参数，loc是起始位置，len是长度。表示字符串要传进来的起始位置和长度。
以上代码的输出结果为：
在修改字符串的时候，由于NSString字符串不可改变，因此实际上原来的字符串对象并不改变，只是将新生成的字符串重新赋值给原来的指针变量。例如这句代码：
str1 = [str1 stringByAppendingString: @",iOS!"];
1.2 NSMutableString 可变字符串
NSString字符串是不可变的字符串，即一旦NSString对象被创建，其中的字符序列就不能更改了。而NSMutableString字符串就不一样了，它的字符串序列是可更改的。而且NSMutableString是NSString的子类，因此，上一节说的NSString的方法，NSMutableString都可以直接使用。
NSMutableString提供了以下的方法来改变字符串字符序列：
| appendString： | 追加固定字符串 |
| appendFormat： | 追加带变量的字符串 |
| deleteCharactersInRange： | 删除某范围字符串 |
| insertString： atIndex： | 在指定位置插入字符串 |
| replaceCharactersInRange： withString： | 将指定位置的字符串替换为另一个字符串 |
接下来用代码来演示如上的功能：
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSString *book = @"《疯狂iOS》";
NSMutableString *str1 = [NSMutableString stringWithString: @"Hello"];
[str1 appendString: @",iOS!"];//追加固定字符串
NSLog(@"%@",str1);
[str1 appendFormat:@"%@是一本非常不错的图书",book];//追加带变量的字符串
NSLog(@"%@",str1);
[str1 insertString:@"fkit.org" atIndex: 6];//在指定位置插入字符串
NSLog(@"%@",str1);
[str1 deleteCharactersInRange: NSMakeRange(6, 12)];//删除第六到第十二个字符
NSLog(@"%@",str1);
[str1 replaceCharactersInRange:NSMakeRange(6, 15) withString:@"Objective-C"];//将第六到第十五个字符改为“Objective-C”
NSLog(@"%@",str1);
}
return 0;
}
程序运行的结果为：
而在NSMutableString的代码中，由于NSMutableString的字符串是可变的，因此修改字符串的时候，字符串所包含的字符序列本身就发生了改变，因此无需重新赋值，比如说上面代码的这一句：
[str1 appendString: @",iOS!"];
二、日期与时间
2.1 日期与时间（NSDate）
OC为处理日期、时间提供了NSDate、NSCalendar对象。
其中，NSDate对象代表日期与时间，OC既提供了类方法来创建NSDate对象，也提供了大量init开头的方法来初始化NSDate对象。创建NSDate的类方法和实例方法基本相似，只是类方法以date开头，实例方法以init开头。
2.2 日期格式器（NSDateFormatter）
NSDateFormatter代表一个日期格式器，它的作用就是完成NSDate和NSString之间的转换。在进行转换时，我们首先需要创建一个NSDateFormatter对象，然后调用该对象的setDateStyle：、setTimeStyle：方法设置格式化日期、时间的风格。其中日期、时间风格支持以下几个枚举值：
| NSDateFormatterNoStyle | 不显示日期、时间的风格 |
| NSDateFormatterShortStyle | 显示“短”的日期、时间的风格 |
| NSDateFormatterLongStyle | 显示“长”的日期、时间的风格 |
| NSDateFormatterMediumStyle | 显示“中等”的日期、时间的风格 |
| NSDateFormatterFullStyle | 显示“完整”的日期、时间的风格 |
除了这几个枚举值，我们还可以通过调用setDateFormate：方法设置日期、时间的风格模版。
如果需要将NSDate转换为NSString，可以调用NSDateFormatter的stringFromDate：方法执行格式化即可；如果需要将NSString转换为NSDate，可以调用NSDateFormatter的dateFromString：方法执行格式化即可。
接下来用代码来演示NSDate和NSDateFormatter的功能：
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
//NSDate的功能演示
NSLog(@"----------------------以下是NSDate的功能运行结果--------------------");
NSDate *date1 = [NSDate date]; //获取当前时间
NSLog(@"%@",date1);
NSDate *date2 = [[NSDate alloc] initWithTimeIntervalSinceNow:3600 * 24];//获取从当前时间开始的后一天的时间
NSLog(@"%@",date2);
NSDate *date3 = [[NSDate alloc] initWithTimeIntervalSinceNow:-3 * 3600 * 24];//获取从现在开始三天前的时间
NSLog(@"%@",date3);
NSDate *date4 = [[NSDate alloc] initWithTimeIntervalSince1970:3600 * 24 * 366 * 20];//获取从1970年1月1日开始往后20年的时间
NSLog(@"%@",date4);
NSLocale *cn = [NSLocale currentLocale];//NSLocale代表一个语言，这里表示中文
NSLog(@"%@",[date1 descriptionWithLocale: cn]);//用中文输出date1的时间
NSDate *earlier = [date1 earlierDate: date2];
NSLog(@"%@",earlier);//获取两个时间中较早的时间
NSDate *later = [date1 laterDate: date2];
NSLog(@"%@",later);//获取两个时间中较晚的时间
//比较两个日期用：compare：方法，它包括如下三个值
//三个值分别代表调用compare的日期位于被比较日期之前、相同、之后
switch([date1 compare: date3]) {
case NSOrderedAscending: NSLog(@"date1在date3之前");
break;
case NSOrderedSame: NSLog(@"date1和date3时间想相同");
break;
case NSOrderedDescending: NSLog(@"date1在date3时间之后");
break;
}
NSLog(@"date1和date3的时间差是%g秒",[date1 timeIntervalSinceDate: date3]);//获取两个时间的时间差
NSLog(@"date2与现在的时间差%g秒",[date2 timeIntervalSinceNow]);//获取指定时间和现在的时间差
//NSDateFormatter的功能
NSLog(@"----------------以下是NSDateFormatter的功能的运行结果----------------");
NSDateFormatter *dt = [NSDate dateWithTimeIntervalSince1970:3600 * 24 * 366 * 20];//格式化时间为从1970年1月1日开始的20年后的时间
NSLocale *locales[] = {[[NSLocale alloc] initWithLocaleIdentifier:@"zh_CN"],[[NSLocale alloc] initWithLocaleIdentifier:@"en_US"]};//创建两个NSLocale分别表示中国、美国
NSDateFormatter *df[8];//为上面两个NSLocale创建8个NSDateFormatter对象
for (int i = 0; i < 2; i++) {
df[i * 4] = [[NSDateFormatter alloc] init];
[df[i * 4] setDateStyle:NSDateFormatterShortStyle];//设置NSDateFormatter的日期、时间风格
[df[i * 4] setTimeStyle:NSDateFormatterShortStyle];
[df[i * 4] setLocale: locales[i]];//设置NSDateFormatter的NSLocale
df[i * 4 + 1] = [[NSDateFormatter alloc] init];
[df[i * 4 + 1]setDateStyle:NSDateFormatterMediumStyle];//设置NSDateFormatter的日期、时间风格
[df[i * 4 + 1]setDateStyle:NSDateFormatterMediumStyle];
[df[i * 4 + 1] setLocale: locales[i]];//设置NSDateFormatter的NSLocale
df[i * 4 + 2] = [[NSDateFormatter alloc] init];
[df[i * 4 + 2] setDateStyle:NSDateFormatterLongStyle];//设置NSDateFormatter的日期、时间风格
[df[i * 4 + 2] setTimeStyle:NSDateFormatterLongStyle];
[df[i * 4 + 2] setLocale: locales[i]];//设置NSDateFormatter的NSLocale
df[i * 4 + 3] = [[NSDateFormatter alloc] init];
[df[i * 4 + 3] setDateStyle:NSDateFormatterFullStyle];//设置NSDateFormatter的日期、时间风格
[df[i * 4 + 3] setTimeStyle:NSDateFormatterFullStyle];
[df[i * 4 + 3] setLocale: locales[i]];//设置NSDateFormatter的NSLocale
}
for (int i = 0; i < 2; i++) {
switch (i) {
case 0: NSLog(@"-----中国日期格式------");
break;
case 1: NSLog(@"-----美国日期格式------");
break;
}
NSLog(@"SHORT格式的日期格式：%@",[df[i * 4] stringFromDate: dt]);
NSLog(@"MEDIUM格式的日期格式：%@",[df[i * 4 + 1] stringFromDate: dt]);
NSLog(@"LONG格式的日期格式：%@",[df[i * 4 + 2] stringFromDate: dt]);
NSLog(@"FULL格式的日期格式：%@",[df[i * 4 + 3] stringFromDate: dt]);
}
NSDateFormatter *df2 = [[NSDateFormatter alloc] init];
[df2 setDateFormat:@"公元yyyy年MM月DD日HH时mm分"];//设置自定义格式器模版
NSLog(@"%@",[df2 stringFromDate: dt]);//执行格式化
NSString *dateStr = @"2013-03-02";
NSDateFormatter *df3 = [[NSDateFormatter alloc] init];
[df3 setDateFormat: @"yyyy-MM-DD"];//根据日期字符串的格式设置格式模版
NSDate *date6 = [df3 dateFromString: dateStr];//将字符串转化为NSDate对象
NSLog(@"%@",date6);
}
return 0;
}
上面的代码用到了NSLocale，它代表一个语言、国际环境，在不同的语言、国家环境下显示出来的字符串是不一样的。
上面代码的运行结果：
2.3 日历（NSCalendar）与日期组件（NSDateComponents）
当需要将年、月、日的数值转换为NSDate的时候，或者从NSDate对象中获取其包含的年、月、日信息时，我们就需要将NSDate对象的各个字段数据分开提取。
为了能分开NSDate对象包含的各个字段数据，Foundation框架提供了NSCalendar对象，该对象包含了以下两个常用方法：
1、（NSDateComponents*）components： fromDate： ：从NSDate提取年、月、日、时、分、秒各时间字段的信息。
2、dateFromComponents：（NSDateComponents*）comps：使用comps对象包含的年、月、日、时、分、秒各时间字段的信息来创建NSDate。
NSDateComponents对象是专门用于封装年、月、日、时、分、秒各时间字段的信息，该对象只包含了对year、month、day、hour、minute、second、week、weekday等各字段的getter和setter方法。
以下用代码演示NSCalendar和NSDateComponents的功能：
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSCalendar *gregorian = [[NSCalendar alloc] initWithCalendarIdentifier: NSCalendarIdentifierGregorian];//获取代表公历的Calendar对象
NSDate *dt = [NSDate date];//获取当前日期
unsigned unitFlags = NSCalendarUnitYear | NSCalendarUnitMonth | NSCalendarUnitDay | NSCalendarUnitHour | NSCalendarUnitMinute | NSCalendarUnitSecond | NSCalendarUnitWeekday;//定义一个时间字段的旗标，指定将会获取指定年、月、日、时、分、秒的信息
NSDateComponents *comp = [gregorian components: unitFlags fromDate: dt];//获取不同时间字段的信息
//获取各时间字段的数值
NSLog(@"现在是%ld年",comp.year);
NSLog(@"现在是%ld月",comp.month);
NSLog(@"现在是%ld日",comp.day);
NSLog(@"现在是%ld时",comp.hour);
NSLog(@"现在是%ld分",comp.minute);
NSLog(@"现在是%ld秒",comp.second);
NSLog(@"现在是星期%ld",comp.weekday);//这里输出的数字会比按照日历的星期数多一，是因为按西方他们是把周天当每周的第一天的
NSDateComponents *comp2 = [[NSDateComponents alloc] init];//再次创建一个NSDateComponents对象
//设置各时间字段的数值
comp2.year = 2023;
comp2.month = 5;
comp2.day = 10;
comp2.hour = 18;
comp2.minute = 15;
//通过NSDateComponents所包含的时间字段的数值来恢复NSDate对象
NSDate *date = [gregorian dateFromComponents: comp2];
NSLog(@"获取的日期为：%@",date);
}
return 0;
}
上面代码的运行结果是：
注：这里输出的星期的数字会比按照日历的星期数多一，是因为按西方他们是把周天当每周的第一天的。
2.4 定时器（NSTimer）
当程序需要让某个方法重复执行，可以借助OC中的定时器来完成。
通过调用NSTimer的scheduledTimerWithTimeInterval： invocation： repeats：或scheduledTimerWithTimeInterval： targe：selector： userInfo： repeats：类方法来创建NSTimer对象。调用该方法时需要传入以下参数：
1、timeInterval：指定每隔多少秒执行一次任务
2、invocation或target与selector：指定重复执行的任务。如果指定target和selector参数，则指定用某个对象的特定方法作为重复执行的任务；如果指定invocation参数，该参数需要传入一个NSInvocation对象，该对象也是封装target和selector的，其实也是指定用某个对象的特定方法作为重复执行的任务。
3、userInfo：该参数用于传入额外的附加信息。
4、repeats：该参数需要指定一个BOOL值，该参数控制是否需要重复执行任务。
在执行完定时器后，也需要销毁定时器，只要调用定时器的invalidate方法即可。
三、对象复制
3.1 copy与mutableCopy方法
copy方法用于复制对象的副本，复制下来的该副本是不可修改的，哪怕是调用NSMutableString的copy方法也不可修改。
而mutableCopy方法复制下来的副本是可修改的，即使被复制的对象原本是不可修改的。例如调用mutableCopy方法复制NSString的，返回的是一个NSMutableString对象。
因为以上方法返回的是原对象的副本，所以对复制的副本进行修改时，原对象通常不受影响。
以下用代码演示copy和mutableCopy方法的功能：
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
//copy与mutableCopy
NSMutableString *book = [NSMutableString stringWithString: @"疯狂iOS讲义"];//定义一个book字符串
NSMutableString *bookCopy = [book mutableCopy];//用mutableCopy给book复制一个副本
[bookCopy replaceCharactersInRange: NSMakeRange(2, 3) withString: @"Android"];//复制后的bookCopy副本是可以修改的，这里做个修改，对原字符串的值也没有影响
NSLog(@"book的值为：%@",book);//原值
NSLog(@"bookCopy的值为：%@",bookCopy);//副本修改后的值，没有问题
NSString *str = @"fkit";//定义一个str字符串
NSMutableString *strCopy = [str mutableCopy];//用mutableCopy给str复制一个副本
[strCopy appendString:@".org"];//向可变字符串后面追加字符串
NSLog(@"%@",strCopy);
NSMutableString *bookCopy2 = [book copy];//用copy方法复制一个book的副本（这个副本不可变）
[bookCopy2 appendString:@"aa"];//这里会报错，因为copy创建的副本不可变，修改了就崩了
}
return 0;
}
以上代码的运行结果是：
在修改用copy复制的bookCopy2时，会发生报错，可见copy复制的副本是不可以被修改的。
3.2 NSCopying和NSmutableCopying协议
当我们想将自定义类用上一节的两个方法复制副本时，我们可能会直接创建完对象后用”类名* 对象2 = [对象1 copy]；“这样的格式来复制副本，但实际上直接这样复制是不对的，会报错说找不到copyWithZone：方法，mutableCopy也是一样。因此我们可以看出，自定义类是不能直接调用这两个方法来复制自身的。
这是为什么呢？是因为当程序调用copy/mutableCopy方法复制时，程序底层需要调用copyWithZone：/mutableCopyWithZone：方法来完成复制的工作，并返回这两个方法的值。因此为了保证可以复制，需要在自定义类的接口部分声明NSCopying/NSMutableCopying协议，然后再类的实现部分增加copyWithZone：/mutableCopyWithZone：方法，因此，对自定义对象的复制应该如下所示：
先定义一个FKDog的接口部分，在接口部分写入NSCopying协议：
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface FKDog : NSObject<NSCopying>
@property (nonatomic,strong) NSMutableString *name;
@property (nonatomic,assign) int age;
@end
NS_ASSUME_NONNULL_END
然后再在实现部分增加copyWithZone：方法：
#import "FKDog.h"
@implementation FKDog
@synthesize name;
@synthesize age;
- (id) copyWithZone:(NSZone *)zone {
NSLog(@"--执行copyWithZon--");
//使用zone参数创建FKDog对象
FKDog *dog = [[[self class] allocWithZone: zone] init];
dog.name = self.name;
dog.age = self.age;
return dog;
}
@end
主函数测试及结果：
#import <Foundation/Foundation.h>
#import "FKDog.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
FKDog *dog1 = [FKDog new];//新建一个dog1对象
dog1.name = [NSMutableString stringWithString:@"旺财"];//用可变字符串的方式将dog1的名字赋值为旺财
dog1.age = 20;
FKDog *dog2 = [dog1 copy];//不添加协议这里会报错
//FKDog *dog3 = [dog1 mutableCopy];//不添加协议的话这里也会报错，原因是自定义类不能直接调用这两个方法来复制自身
dog2.name = [NSMutableString stringWithString:@"snoopy"];
dog2.age = 12;
NSLog(@"dog1的名字是：%@，年龄是：%d",dog1.name,dog1.age);
NSLog(@"dog2的名字是：%@，年龄是：%d",dog2.name,dog2.age);
}
return 0;
}
有一个问题：前面说copy方法复制的时候，它复制的对象应该是不可变的副本，但是为什么此处调用了copy方法复制后依然是一个可变的FKDog对象呢？
这是因为此处的FKDog没有提供对应的不可变类，自然也就无法复制不可变的FKDog对象。如果程序为FKDog提供了不可变类，当然还是应该让FKDog的copyWithZone：返回不可变的FKDog对象。
如果重写copyWithZone：方法的时候，其父类已经实现了NSCopying协议，并重写过copyWithZone方法，那么子类重写copyWithZone：方法的时候应该先调用父类的copy方法复制从父类得到的成员变量，然后对自类中定义的成员变量进行赋值。
假如父类已经重写copyWithZone：方法，那么子类重写copyWithZone方法的格式如下：
- (id) copyWithZone:(NSZone*)zone {
id obj = [super copy];
//对自类定义的成员变量赋值
......
return obj;
}3.3 深复制和浅复制
首先，用代码来演示一下深复制和浅复制的概念：
我们先定义一个FKDog类，它的接口和实现部分如下所示：
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface FKDog : NSObject<NSCopying>
@property (nonatomic,strong) NSMutableString *name;
@property (nonatomic,assign) int age;
@end
NS_ASSUME_NONNULL_END
#import "FKDog.h"
@implementation FKDog
@synthesize name;
@synthesize age;
- (id) copyWithZone:(NSZone *)zone {
FKDog *dog = [[[self class] allocWithZone:zone] init];
dog.name = self.name;
dog.age = self.age;
return dog;
}
@end
然后在主函数测试及结果：
#import <Foundation/Foundation.h>
#import "FKDog.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
FKDog *dog1 = [FKDog new];
dog1.name = [NSMutableString stringWithString:@"旺财"];
dog1.age = 12;
FKDog *dog2 = [dog1 copy];
[dog2.name replaceCharactersInRange:NSMakeRange(0, 2) withString: @"snoopy"];
NSLog(@"dog1的名字是：%@",dog1.name);
NSLog(@"dog2的名字是：%@",dog2.name);
}
return 0;
}
在上面的代码里，明明只是修改了dog2的name属性，为何dog1的属性也会改变呢？这是因为name只是一个指针变量，该变量中存放的是字符串的地址而非字符串本身，因此此时赋值的效果是让dog对象的name与被复制对象的name指向了同一个字符串的地址，因此输出时，它们输出的其实是同一个字符串，一个对象的name属性被改变时，另一个对象的name属性也会相应改变。这就是浅复制，即程序只是复制了该指针的地址而非真正指向的对象。如图所示：
因此相对的，深复制就是不仅会复制对象本身，而且会“递归”复制每个指针类型的实例变量，直到两个对象没有任何共用的部分。以下是深复制的代码：
接口部分和主函数是和浅复制一模一样的，这里就不详细说了：
接口：
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface FKDog : NSObject<NSCopying>
@property (nonatomic,strong) NSMutableString *name;
@property (nonatomic,assign) int age;
@end
NS_ASSUME_NONNULL_END
主函数：
#import <Foundation/Foundation.h>
#import "FKDog.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
FKDog *dog1 = [FKDog new];
dog1.name = [NSMutableString stringWithString:@"旺财"];
dog1.age = 12;
FKDog *dog2 = [dog1 copy];
[dog2.name replaceCharactersInRange: NSMakeRange(0, 2) withString: @"snoopy"];
NSLog(@"dog1的名字是：%@",dog1.name);
NSLog(@"dog2的名字是：%@",dog2.name);
}
return 0;
}
深浅复制的差异主要体现在实现部分：
#import "FKDog.h"
@implementation FKDog
@synthesize name;
@synthesize age;
- (id) copyWithZone:(NSZone *)zone {
NSLog(@"--执行copyWithZone--");
FKDog *dog = [[[self class] allocWithZone:zone] init];
dog.name = [self.name mutableCopy];//在这个地方与浅复制不同
dog.age = self.age;
return dog;
}
@end
我们可以看出来，深复制的代码在copyWithZone：方法中给name赋值的时候，并不是直接将被复制对象的name实例变量的值赋给新对象的name实例变量，而是先用mutableCopy了一个副本，然后将副本的值赋给name，这样就保证了被复制的对象和新的对象的name变量没有共用的部分，因此两个对象的name对象的值就可以互相不干扰了。这就是深复制。
3.4 setter方法的复制选项
前面说到在合成setter和getter方法的时候可以使用copy指示符，该指示符就是指定当程序调用setter方法复制的时候，实际上是将传入参数的副本赋给程序的实例变量。
下面定义一个FKItem类：
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface FKItem : NSObject
@property (nonatomic,copy) NSMutableString *name;
@end
NS_ASSUME_NONNULL_END
#import "FKItem.h"
@implementation FKItem
@synthesize name;
@end
主函数测试：
#import <Foundation/Foundation.h>
#import "FKItem.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
FKItem *item = [FKItem new];
item.name = [NSMutableString stringWithString:@"疯狂iOS讲义"];
[item.name appendString: @"fkit"];
}
return 0;
}
在运行的时候，我们会发现，[item.name appendString:@"fkit"];这一句会报错。这是因为：
如上的代码是用点语法setter方法给item的name赋值，这里的setter方法相当于在实现部分有如下代码：
- (void) setName: (NSMutableString*) aname {
name = [aname copy];
}而在我们定义name属性的时候用的是copy指示符，复制的是不可变的副本，因此程序赋给FKItem对象的name实例变量的值仍然是不可变字符串。
定义合成getter、setter方法时并没有提供mutableCopy指示符，因此即使定义实例变量的时候用了可变类型，但只要使用了copy指示符，实例变量得到的值总是不可变对象。
四、OC集合概述
OC集合类可以用于存储数量不等的多个对象，并且可以实现常用的数据结构，例如栈和队列等，除此之外，OC集合还可以用来保存具有映射关系的关联数组。
OC的集合大致上可以分为三种体系：
| NSArray | 代表有序、可重复的集合，很像一个数组 |
| NSSet | 代表无序、不可重复的集合 |
| NSDictionary | 代表具有映射关系的集合 |
在实际编程里，面向的是NSArray（及其子类NSMutableArray）、NSSet（及其子类NSMutableSet）、NSDictionary（及其子类NSMutableDictionary）编程，程序创建的也可能是它们的子类的实例。
集合类和数组不一样，数组保存的元素既可以是基本类型的值，也可以是对象（实际上是对象的指针变量）；而集合里只能保存对象（实际上是对象的指针变量）。
OC集合中，NSSet集合类似于一个罐子，把一个对象添加到NSSet集合时，NSSet无法记住添加这个元素的顺序，因此NSSet的元素不可以重复。且访问其元素，只能根据元素本身来访问。
NSArray类似于一个数组，它可以记住每次添加元素的顺序，因此它的元素可以重复，且NSMutableArray的长度可变。访问其中的元素，只需要根据元素的索引来访问。
NSDictionary集合也像一个罐子，只是它里面的每一项数据都由两个值组成。访问其中的元素，可以根据每项元素的key值来访问其value。
五、数组（NSArray和NSMutableArray）
5.1 NSArray的功能与用法
NSArray分别提供了类方法和实例方法来创建NSArray，两种创建方式要传入的参数基本相似，只是类方法由array开头，实例方法以init开头。
创建NSArray对象的几个常见方法：
| array | 创建一个不包含任何元素的空NSArray |
| arrayWithContentsOfFile：/initWithContentsOfFile： | 读取文件内容来创建NSArray |
| arrayWithObject：/initWithObject： | 创建只包含指定元素的NSArray |
| arrayWithObjects：/initWithObjects： | 创建包含指定的n个元素的NSArray |
以下用代码演示一下NSArray的用法：
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
//NSArray集合
NSArray *arr = [NSArray arrayWithObjects:@"疯狂iOS讲义",@"疯狂111",@"疯狂222",@"疯狂333",@"疯狂444", nil];
NSLog(@"第一个元素是：%@",[arr objectAtIndex: 0]);
NSLog(@"索引为1的元素：%@",[arr objectAtIndex: 1]);
NSLog(@"最后一个元素：%@",[arr lastObject]);
//获取索引从2到5的元素组成的新集合
NSArray *arr1 = [arr objectsAtIndexes: [NSIndexSet indexSetWithIndexesInRange:NSMakeRange(2, 3)]];
NSLog(@"%@",arr1);
//获取元素在集合中的位置
NSLog(@"疯狂111的位置为：%ld",[arr indexOfObject: @"疯狂111"]);
//获取元素在集合指定范围中的位置
NSLog(@"疯狂111的位置为：%ld",[arr indexOfObject: @"疯狂111" inRange:NSMakeRange(2, 3)]);
//向数组的末尾追加元素
//原arr的本身没有变，只是将新返回的NSArray赋给arr
arr = [arr arrayByAddingObject:@"晓美焰"];//追加单个元素
arr = [arr arrayByAddingObjectsFromArray:[NSArray arrayWithObjects: @"鹿目圆",@"美树沙耶香", nil]];//将另一个数组中所有元素追加到原数组后面
for (int i = 0; i < arr.count; i++) {
NSLog(@"%@",[arr objectAtIndex: i]);//也可简写为：NSLog(@"%@",[array objectAtIndex: i]);
}
//获取array数组中索引为5到8的所有元素
NSArray *arr2 = [arr subarrayWithRange: NSMakeRange(5, 3)];
//将NSArray集合的元素写入文件
[arr2 writeToFile: @"myFile.txt" atomically: YES];
for (int j = 0; j < 8; j++) { //也可以用下标法来访问元素
NSLog(@"%@",arr[j]);
}
}
return 0;
}
在上面的代码中，传入集合的元素中的最后一个是nil，代表NSArray元素结束，其实这个nil元素并不会存入NSArray集合中。
上面代码还用了一个NSIndexSet集合，这个集合和NSSet的功能基本相似，区别只是NSIndexSet集合主要用于保存索引值，因此它的集合都是NSUInteger对象。
在iOS 5.0以上的版本可以直接用下标法来访问元素，以下两个代码作用是相同的：
[array objectAtIndex: i];
array[i];
上面代码的运行结果：
对于上面的方法，无论哪种都无法修改NSArray对象（因为NSArray集合本身是不能修改的），程序只是返回一个新的NSArray对象。
5.1.1 NSArray判断指定元素位置的标准
NSSArray判断指定元素位置的标准只有一条：只有某个集合元素与被查找的元素通过isEqual：方法比较返回YES，即可认为该NSArray集合包含该元素，并不需要两个元素是同一个元素。
下面用代码来证实NSArray的比较机制：
首先先定义一个FKUser类，接口和实现如下：
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface FKUser : NSObject
@property (nonatomic,copy) NSString *name;
@property (nonatomic,copy) NSString *pass;
- (id) initWithName: (NSString*) aName pass: (NSString*) aPass;
- (void) say: (NSString*) content;
@end
NS_ASSUME_NONNULL_END
#import "FKUser.h"
@implementation FKUser
@synthesize name;
@synthesize pass;
- (id) initWithName:(NSString *)aName pass:(NSString *)aPass {
if (self = [super init]) {
name = aName;
pass = aPass;
}
return self;
}
- (void) say: (NSString*) content {
NSLog(@"%@说：%@",self.name,content);
}
- (BOOL) isEqual:(id)other {
if (self == other) {
return YES;
}
if ([other class] == FKUser.class) {
FKUser *target = (FKUser*)other;
return [self.name isEqualToString: target.name] && [self.pass isEqualToString: target.pass];
}
return NO;
}
//为了直接看到FKUser的内部状态，因此改写了description方法
- (NSString*) description {
return [NSString stringWithFormat:@"<FKUser[name = %@,pass = %@>",self.name,self.pass];
}
@end
主函数及运行结果：
#import <Foundation/Foundation.h>
#import "FKUser.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSArray *array = [NSArray arrayWithObjects:[[FKUser alloc] initWithName: @"sun" pass: @"123"],[[FKUser alloc] initWithName: @"bai" pass: @"345"],[[FKUser alloc] initWithName: @"zhu" pass: @"654"],[[FKUser alloc] initWithName: @"tang" pass: @"178"],[[FKUser alloc] initWithName: @"niu" pass: @"155"], nil];
FKUser *newUser = [[FKUser alloc] initWithName: @"zhu" pass: @"654"];
NSUInteger pos = [array indexOfObject: newUser];
NSLog(@"newUser的位置为：%ld",pos);
}
return 0;
}
5.2 对集合元素整体调用方法
对于简单的调用集合中的元素的方法，可以通过NSArray的如下两种方法：
1、makeObjectsPerformSelector：依次调用元素中每个元素的指定方法，该方法需要传入一个SEL参数，用于指定调用哪种方法。
2、makeObjectsPerformSelector： withObject：：依次调用NSArray集合中的每个元素的指定方法，该方法第一个SEL参数用于指定调用哪个方法；第二个参数用于调用集合元素的方法时传入参数；第三个参数用于控制是否中止迭代，如果在处理某个元素后，将第三个元素赋为YES，该方法就会中止迭代使用。
如果希望对集合中的所有元素进行隐式访问，并使用集合元素来执行某一段代码，则可通过NSArray的以下方法来完成。
1、enumerateObjectsUsingBlock：：遍历集合中的所有元素，并依次使用元素来执行指定的代码块。
2、enumerateObjectsWithOptions： usingBlock：：遍历集合中的所有元素，并依次使用元素来执行指定的代码块。该方法可以额外传入一个参数，用于控制遍历的选项，如反向遍历。
3、enumerateObjectsAtIndexes：options：usingBlock：：遍历集合中指定范围内的元素，并依次使用元素来执行指定的代码块。该方法可以传入一个选项参数，用于控制遍历的选项，如反向遍历。
上面方法都必须传入一个代码块参数，该代码块必须带三个参数，前一个参数代表正在遍历的集合元素，第二个参数代表正在遍历的集合元素的索引。
接下来用代码来演示上面的方法：
定义一个FKUser类：
#import <Foundation/Foundation.h>
#import "FKUser.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSArray *array = [NSArray arrayWithObjects:[[FKUser alloc] initWithName: @"sun" pass: @"123"],[[FKUser alloc] initWithName: @"bai" pass: @"345"],[[FKUser alloc] initWithName: @"zhu" pass: @"654"],[[FKUser alloc] initWithName: @"tang" pass: @"178"],[[FKUser alloc] initWithName: @"niu" pass: @"155"], nil];
FKUser *newUser = [[FKUser alloc] initWithName: @"zhu" pass: @"654"];
NSUInteger pos = [array indexOfObject: newUser];
NSLog(@"newUser的位置为：%ld",pos);
}
return 0;
}
#import "FKUser.h"
@implementation FKUser
@synthesize name;
@synthesize pass;
- (id) initWithName:(NSString *)aName pass:(NSString *)aPass {
if (self = [super init]) {
name = aName;
pass = aPass;
}
return self;
}
- (void) say: (NSString*) content {
NSLog(@"%@说：%@",self.name,content);
}
- (BOOL) isEqual:(id)other {
if (self == other) {
return YES;
}
if ([other class] == FKUser.class) {
FKUser *target = (FKUser*)other;
return [self.name isEqualToString: target.name] && [self.pass isEqualToString: target.pass];
}
return NO;
}
- (NSString*) description {
return [NSString stringWithFormat:@"<FKUser[name = %@,pass = %@>",self.name,self.pass];
}
@end
主函数及运行结果：
#import <Foundation/Foundation.h>
#import "FKUser.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSArray *array = [NSArray arrayWithObjects:[[FKUser alloc] initWithName: @"sun" pass: @"123"],[[FKUser alloc] initWithName: @"bai" pass: @"345"],[[FKUser alloc] initWithName: @"zhu" pass: @"654"],[[FKUser alloc] initWithName: @"tang" pass: @"178"],[[FKUser alloc] initWithName: @"niu" pass: @"155"], nil];
[array makeObjectsPerformSelector: @selector(say:) withObject: @"下午好，NSArray真强大!"];
NSString *content = @"疯狂iOS讲义";
[array enumerateObjectsAtIndexes:[NSIndexSet indexSetWithIndexesInRange:NSMakeRange(2, 2)] options:NSEnumerationReverse usingBlock:^(id obj,NSUInteger idx,BOOL *stop) {
NSLog(@"正在处理第%ld个元素：%@",idx,obj);
[obj say: content];
}];
}
return 0;
}
5.3 对NSArray进行排序
对NSArray排序的常用方法有以下几种：
| sortedArrayUsingFunction： context： | 该方法使用排序函数对集合元素进行排序，该排序函数必须返回NSOrderedDescending（降序）、NSOrderedAscending（升序）、NSOrderedSame（同序）这些枚举值，用于代表集合元素的大小。该方法返回一个排好序的新NSArray对象。 |
| sortedArrayUsingSelector： | 该方法使用集合元素自身的方法对集合元素进行排序，集合元素的该方法必须返回NSOrderedDescending（降序）、NSOrderedAscending（升序）、NSOrderedSame（同序）这些枚举值，用于代表集合元素的大小。返回一个排好序的新NSArray对象。 |
| sortedArrayUsingComparator： | 该方法使用代码块对集合元素进行排序，该代码块必须返回NSOrderedDescending（降序）、NSOrderedAscending（升序）、NSOrderedSame（同序）这些枚举值，用于代表集合元素的大小。返回一个排好序的新NSArray对象。 |
以下用代码来演示一下上述的方法：
#import <Foundation/Foundation.h>
//定义一个比较函数，根据两个对象的intValue进行比较
NSInteger intSort(id num1,id num2,void *context) {
int v1 = [num1 intValue];
int v2 = [num2 intValue];
if (v1 < v2)
return NSOrderedAscending;
else if (v1 > v2)
return NSOrderedDescending;
else
return NSOrderedSame;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSArray *array1 = [NSArray arrayWithObjects: @"Objective-C",@"C",@"C++",@"Ruby",@"Perl",@"Python",nil];//初始化一个元素为NSString的NSArray对象
//使用集合的compare：方法进行排序
array1 = [array1 sortedArrayUsingSelector: @selector(compare:)];
NSLog(@"%@",array1);
NSArray *array2 = [NSArray arrayWithObjects: [NSNumber numberWithInt:20],[NSNumber numberWithInt:12],[NSNumber numberWithInt:-8],[NSNumber numberWithInt:50],[NSNumber numberWithInt:19],nil];//初始化一个元素为int的NSArray对象
//使用intSort函数进行排序
array2 = [array2 sortedArrayUsingFunction: intSort context: nil];
NSLog(@"%@",array2);
//使用代码块对array2的元素进行排序
NSArray *array3 = [array2 sortedArrayUsingComparator: ^(id obj1,id obj2) {
//该代码块根据集合元素的intValue进行比较
if ([obj1 intValue] > [obj2 intValue]) {
return NSOrderedDescending;
}
if ([obj1 intValue] < [obj2 intValue]) {
return NSOrderedAscending;
}
return NSOrderedSame;
}];
NSLog(@"%@",array3);
}
return 0;
}
运行结果：
在上述代码中，我们可以看见第一种方法使用NSString自身的compare：方法进行排序。这是因为NSString自身已经实现了compare：方法，这意味着NSString对象本身就可以比较大小——NSString自身比较大小的方法是根据字符对应的编码来的。
compare：方法的比较是：compare在要比较的字符串中，依次取出对应的数组元素,按ascii码值比较,如果ascii值能比较出结果了,就不往后比较。默认返回值为升序
后两种方法通过调用代码块或者函数来比较大小，代码块相当于一个匿名函数，因此后面两种方式的本质是一样的，它们都可以通过自定义的比较规则来比较集合元素的大小。
5.4 使用枚举遍历器遍历NSSArray集合元素
可以调用NSArray对象的如下两个方法来返回枚举器：
1、objectEnumerator：返回NSArray集合的顺序枚举器。
2、reverseObjectEnumerator：返回NSArray逆序枚举器。
上面两个方法都返回一个NSEnumerator枚举器，该枚举器只包含如下两个方法：
1、allObjects：获取被枚举集合中的所有元素。
2、nextObject：获取被枚举集合中的下一个元素。
借助nextObject方法即可对集合元素进行枚举：程序可采用循环不断获取nextObject方法的返回值，直到该方法的返回值为nil结束循环。
用以下代码演示上述方法：
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSArray *array = [NSArray arrayWithObjects: @"晓美焰",@"鹿目圆",@"巴麻美",@"美树沙耶香",nil];//初始化一个NSArray集合
//获取NSArray的顺序枚举器
NSEnumerator *en = [array objectEnumerator];
id object;
while (object = [en nextObject]) {
NSLog(@"%@",object);
}
NSLog(@"-----下面是逆序遍历------");
//获取NSArray的逆序枚举器
en = [array reverseObjectEnumerator];
while (object = [en nextObject]) {
NSLog(@"%@",object);
}
}
return 0;
}
运行结果：
5.5 快速枚举（for...in）
OC提供了一种快速枚举的方法来遍历集合（包括NSArray、NSSet、NSDictionary等集合），使用快速枚举遍历集合元素的时候，无需获取集合的长度，也无需根据索引来访问集合元素，即可快速枚举自动遍历集合的每个元素。其语法格式如下：
for (type variableName in collection) {
//variableName自动迭代访问每个元素
}在上面的语法格式中，type是集合元素的类型，variableName是一个形参名，快速枚举将自动将集合元素赋给该变量。如果使用快速枚举来遍历NSDictionary对象，快速枚举中循环计数器依次代表NSDictionary的每个key值。
快速枚举的本质是一个foreach循环，foreach循环和普通循环不同的是，它无需循环条件，也无需循环迭代语句，这些部分都是由系统来完成的，foreach循环自动迭代数组的每个元素，当每个元素都被迭代一次后，foreach循环自动结束。
代码示例：
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSArray *array = [NSArray arrayWithObjects:@"晓美焰",@"鹿目圆",@"巴麻美",@"美树沙耶香",nil];
for (id object in array) {
NSLog(@"%@",object);
}
}
return 0;
}
运行结果：
5.6 可变数组(NSMutableArray)
NSArray代表元素不可变的集合，一旦NSArray创建成功，程序中不能向集合中添加新的元素，不能删除已有的元素，也不能替换集合元素。NSArray只是保存对象的指针，因此，NSArray只保证这些指针变量中的地址不能改变，但指针变量所指向的对象是可改变的。
NSMutableArray是NSArray的子类，因此它可以当作NSArray使用。它代表一个元素可变的集合，因此它程序可以向它中增添、删除、替换元素。创建NSMutableArray时可以通过参数指定底层数组的初始容量。
NSMutableArray新增了以下方法：
| 添加集合元素的方法 | 以add开头 |
| 删除集合元素的方法 | 以remove开头 |
| 替换集合中元素的方法 | 以replace开头 |
| 对集合本身排序的方法 | 以sort开头 |
NSMutableArray还提供了sortUsingSelector：、sortUsingComparator：、sortUsingFunction： context：方法，它们与前面介绍的NSArray的排序的方法类似，区别是NSArray的排序的方法返回的是一个新的NSArray对象，而NSMutableArray返回的是排序后的原来的对象。
下面用代码演示：
#import <Foundation/Foundation.h>
//定义一个函数，该函数用于把NSArray集合转换为字符串
//这样方便我们调试的时候看到NSArray集合中的元素
NSString *NSCollectionToString(NSArray *array) {
NSMutableString *result = [NSMutableString stringWithString:@"["];
for (id obj in array) {
[result appendString: [obj description]];
[result appendString:@","];
}
NSUInteger len = [result length];//获取字符串长度
[result deleteCharactersInRange:NSMakeRange(len - 1, 1)];//去掉最后一个字符
[result appendString:@"]"];
return result;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
//初始化NSMutableArray集合
NSMutableArray *array = [NSMutableArray arrayWithObjects:@"晓美焰",@"鹿目圆",@"巴麻美",@"美树沙耶香", nil];
//向集合最后追加元素
[array addObject:@"佐仓杏子"];
NSLog(@"追加一个元素后:%@",NSCollectionToString(array));
[array addObjectsFromArray:[NSArray arrayWithObjects:@"丘比",@"仁美", nil]];
NSLog(@"最后追加两个元素后：%@",NSCollectionToString(array));
//向集合指定位置插入元素
[array insertObject:@"蓓蓓" atIndex:2];
NSLog(@"在索引为2的位置插入一个元素后：%@",NSCollectionToString(array));
[array insertObjects:[NSArray arrayWithObjects:@"吼拉姆",@"馒头卡", nil] atIndexes:[NSIndexSet indexSetWithIndexesInRange:NSMakeRange(3, 2)]];
NSLog(@"插入多个元素后：%@",NSCollectionToString(array));
//删除集合中指定位置的元素
[array removeLastObject];
NSLog(@"删除最后一个元素后：%@",NSCollectionToString(array));
[array removeObjectAtIndex:5];
NSLog(@"删除索引为5的元素后：%@",NSCollectionToString(array));
[array removeObjectsInRange:NSMakeRange(2, 3)];
NSLog(@"删除索引为2-5的元素后：%@",NSCollectionToString(array));
//替换集合中指定位置的元素
[array replaceObjectAtIndex:2 withObject:@"Q币"];
NSLog(@"替换索引为2处的元素后：%@",NSCollectionToString(array));
}
return 0;
}
运行结果：
5.7 NSArray的KVC与KVO
NSArray是一个容纳多个对象的集合，它允许直接对集合中的所有元素进行整体的KVC编码，NSArray提供了如下两个方法：
1、setValue： forKey：：将NSArray集合中所有元素的指定key对应属性或实例变量设置为value。
2、valueForKey：：返回该NSArray集合中所有元素的指定key所组成的NSArray对象。
除此之外，NSArray还为对集合中的所有元素或部分元素进行KVO编程提供了如下方法：
1、addObserver: forKeyPath: options: context:：为集合中的所有元素添加KVO监听器。
2、removeObserver: forKeyPath:：为集合中的所有元素删除KVO监听器。
3、addObserver: toObjectsAtIndexes: forKeyPath: options: context:：为集合中指定索引处的元素添加KVO监听器。
4、removeObserver: fromObjectsAtIndexes: forKeyPath:：为集合中指定索引处的元素删除KVO监听器。
六、集合（NSSet与NSMutableSet）
6.1 NSSet的功能与用法
在前面说过，NSSet集合就像一个罐子，把对象放进去后是无序的，因此里面的元素不能重复。NSSet按Hash算法来存储集合中的元素，因此具有很好的存取和查找功能。与NSArray相比，NSSet最大的区别是元素没有索引，因此前面的NSArray的所有关于索引的方法都不能用于NSSet。
但是NSSet和NSArray还是有相似之处，比如：1、它们都可以通过count方法来获取集合元素的数量。2、都可以使用快速枚举来集合遍历元素。3、都可以通过objectEnumerator方法获取NSEnumerator枚举器对集合元素进行遍历。4、都提供了makeObjectsPerformSelector：、makeObjectsPerformSelector：withObject：方法对集合元素整体调用某个方法，以及enumerateObjectsUsingBlock：、enumerateObjectsWithOptions：usingBlock对集合整体或部分元素迭代执行代码块。5、都提供了valueForKey：和setValue： forKey：方法对集合元素进行KVC编程。6、都提供了集合所有元素和部分元素进行KVC编程的方法。
在NSSet集合中同样，以set开头的是类方法，以init开头的是实例方法。
接下来用代码来介绍NSSet的各方法：
#import <Foundation/Foundation.h>
//定义一个函数，可以把NSSet集合转化为字符串
//方便我们调试观察结果
NSString *NSCollectionToString(id collection) {
NSMutableString *result = [NSMutableString stringWithString: @"["];
for (id obj in collection) {
[result appendString: [obj description]];
[result appendString:@","];
}
NSUInteger len = [result length];//获取字符串长度
[result deleteCharactersInRange: NSMakeRange(len - 1, 1)];//去除最后一个字符
[result appendString: @"]"];
return result;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
//初始化集合set1和set2
//在初始化集合set1的时候故意传入两个相同的元素，可以看到结果是只保留了一个
NSSet *set1 = [NSSet setWithObjects: @"晓美焰", @"晓美焰", @"鹿目圆", @"巴麻美", nil];
NSLog(@"set1集合中元素个数为%ld", [set1 count]);
NSLog(@"s1集合：%@",NSCollectionToString(set1));
NSSet *set2 = [NSSet setWithObjects: @"巴麻美", @"美树沙耶香", @"佐仓杏子", nil];
NSLog(@"s2集合：%@", NSCollectionToString(set2));
//向集合中追加单个元素
set1 = [set1 setByAddingObject: @"丘比"];
NSLog(@"添加一个元素后：%@", NSCollectionToString(set1));
//获取两个集合的并集
NSSet *s = [set1 setByAddingObjectsFromSet: set2];
NSLog(@"set1和set2的并集：%@", NSCollectionToString(s));
//判断两个集合是否有交集
BOOL b = [set1 intersectsSet: set2];
NSLog(@"set1和set2是否有交集：%d", b);
//判断一个集合是否是另一个集合的子集
BOOL bo = [set2 isSubsetOfSet: set1];
NSLog(@"set2是否是set1的子集：%d", bo);
//判断集合中是否包含某个元素
BOOL bb = [set1 containsObject: @"鹿目圆"];
NSLog(@"set1是否包含鹿目圆：%d", bb);
//随机从集合中取出一个元素，但是同时写两个下面的代码输出的结果是相同的
NSLog(@"set1随机取出一个元素：%@", [set1 anyObject]);
NSLog(@"set1随机取出一个元素：%@", [set1 anyObject]);
//使用代码块对集合元素进行过滤
NSSet *filteredSet = [set2 objectsPassingTest: ^(id obj,BOOL *stop) {
return (BOOL)([obj length] > 3);
}];
NSLog(@"set2中的元素长度大于3的集合元素有：%@", NSCollectionToString(filteredSet));
}
return 0;
}运行结果：
6.2 NSSet判断集合元素重复的标准
当向NSSet集合中存入一个元素时，NSSet会调用该对象的Hash方法来得到对象的hashCode值，然后根据该值决定该对象在底层Hash表中的存储位置，如果根据hashCode计算出该元素在底层Hash表中的存储位置已经不相同，那么系统自然的将它们存在不同的位置。
如果两个元素的hashCode相同，接下来就要通过isEqual：方法判断两个元素是否相等，如果有两个元素通过isEqual：方法比较返回NO，NSSet依然认为它们不相等，NSSet会把它们都存在底层的Hash表的同一个位置，只是将在这个位置形成链，后面的元素添加失败。
因此，HashSet集合判断两个元素相等的标准为：1、两个对象通过isEqual：方法比较返回YES；2、两个对象的hash方法返回值相等。
用代码演示：
首先，还是写出FKUser：
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface FKUser : NSObject
@property (nonatomic,copy) NSString *name;
@property (nonatomic,copy) NSString *pass;
- (id) initWithName: (NSString*) aName pass: (NSString*) aPass;
- (void) say: (NSString*) content;
@end
NS_ASSUME_NONNULL_END
#import "FKUser.h"
@implementation FKUser
@synthesize name;
@synthesize pass;
- (id) initWithName:(NSString *)aName pass:(NSString *)aPass {
if (self = [super init]) {
name = aName;
pass = aPass;
}
return self;
}
- (void) say: (NSString*) content {
NSLog(@"%@说：%@",self.name,content);
}
- (BOOL) isEqual:(id)other {
if (self == other) {
return YES;
}
if ([other class] == FKUser.class) {
FKUser *target = (FKUser*)other;
return [self.name isEqualToString: target.name] && [self.pass isEqualToString: target.pass];
}
return NO;
}
- (NSString*) description {
return [NSString stringWithFormat:@"<FKUser[name = %@,pass = %@>",self.name,self.pass];
}
@end
然后是主函数和运行结果：
#import <Foundation/Foundation.h>
#import "FKUser.h"
NSString *NSCollectionToString (id array) {
NSMutableString *result = [NSMutableString stringWithString: @"["];
for (id obj in array) {
[result appendString: [obj description]];
[result appendString: @","];
}
NSUInteger len = [result length];
[result deleteCharactersInRange: NSMakeRange(len - 1, 1)];
[result appendString: @"]"];
return result;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSSet *set = [NSSet setWithObjects: [[FKUser alloc] initWithName: @"sun" pass: @"123"], [[FKUser alloc] initWithName: @"bai" pass: @"345"], [[FKUser alloc] initWithName: @"sun" pass: @"123"], [[FKUser alloc] initWithName: @"tang" pass: @"178"], [[FKUser alloc] initWithName: @"niu" pass: @"155"], nil];
NSLog(@"set集合元素的个数：%ld", [set count]);
NSLog(@"%@", NSCollectionToString(set));
}
return 0;
}
在主函数为集合添加元素的时候，故意将相同值的元素添加了两遍，结果发现那个元素在集合中真就出现了两遍，但是我们知道NSSet中是不能有重复元素的，这是为什么呢，这是因为该程序只重写了isEqual方法但是没有重写hash方法，然后导致两个新元素的hashCode不相同，使得NSSet认为它们两个不相等，就都存到集合中了。因此，应该再按如下重写hash方法：
- (NSUInteger) hash {
NSLog(@"===hash===");
NSUInteger nameHash = name == nil ? 0 : [name hash];
NSUInteger passHash = pass == nil ? 0 : [pass hash];
return nameHash * 31 + passHash;
}
重写hash方法的基本规则：
1、程序运行过程中，同一个对象多次调用hash方法应该返回相同的值。
2、当两个对象通过isEqual：方法比较返回YES时，两个对象的hash应该返回相同的值
3、对象中作为isEqual：比较标准的实例变量，都应该用来hashCode值
6.3 NSMutableSet的功能和用法
和前面类似，NSMutableSet和NSSet的区别是前者可变后者不可变。NSMutableSet在NSSet的基础上新增了这几个方法：
| addObject： | 向集合中添加单个元素 |
| removeObject： | 从集合中删除单个元素 |
| removeAllObject： | 删除集合中所有元素 |
| addObjectsFromArray： | 使用NSArray数组作为参数，向NSSet集合中添加参数数组中的所有元素 |
| unionSet： | 计算两个NSSet元素的并集 |
| minusSet： | 计算两个NSSet集合的差集 |
| intersectSet： | 计算两个NSSet集合的交集 |
| setSet： | 用后一个集合的元素替换已有集合中所有元素 |
用代码演示上述方法：
#import <Foundation/Foundation.h>
//定义一个函数，可以把NSSet集合转化为字符串
//方便我们调试观察结果
NSString *NSCollectionToString(id collection) {
NSMutableString *result = [NSMutableString stringWithString: @"["];
for (id obj in collection) {
[result appendString: [obj description]];
[result appendString: @","];
}
NSUInteger len = [result length];//获取字符串长度
[result deleteCharactersInRange: NSMakeRange(len - 1, 1)];//去除最后一个字符
[result appendString: @"]"];
return result;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
//创建一个初始容量为10的set集合
NSMutableSet *set = [NSMutableSet setWithCapacity: 10];
//向集合中添加一个元素
[set addObject: @"疯狂iOS讲义"];
NSLog(@"set添加一个元素后：%@", NSCollectionToString(set));
//利用NSArray向集合中添加多个元素
[set addObjectsFromArray: [NSArray arrayWithObjects: @"疯狂andro讲义", @"疯狂Ajax讲义", @"疯狂XML讲义", nil]];
NSLog(@"set使用NSArray添加三个元素后：%@", NSCollectionToString(set));
//删除集合中指定元素
[set removeObject: @"疯狂XML讲义"];
NSLog(@"set删除一个元素后：%@", NSCollectionToString(set));
NSSet *set2 = [NSSet setWithObjects: @"晓美焰", @"疯狂iOS讲义", nil];
//计算两个集合的并集
[set unionSet: set2];
NSLog(@"set和set2的并集：%@", NSCollectionToString(set));
//计算两个集合的差集
[set minusSet: set2];
NSLog(@"set和set2的差集：%@", NSCollectionToString(set));
//计算两个集合的交集
[set intersectSet: set2];
NSLog(@"set和set2的交集：%@", NSCollectionToString(set));
//用set2的集合元素替换set集合的所有元素
[set setSet: set2];
NSLog(@"用set2的集合元素替换set集合的所有元素：%@", NSCollectionToString(set));
}
return 0;
}
运行结果：
6.4 NSCountedSet的功能和用法
NSCountedSet是NSMutableSet的子类，它与NSMutableSet集合不同的是：NSCountedSet为每个元素额外维护一个添加次数的状态。当程序向NSCountedSet中添加一个元素的时候，如果NSCountedSet集合中不包含该元素，NSCountedSet接纳该元素，并将该元素的添加次数标记为1；当程序向NSCountedSet中添加一个元素的时候，如果NSCountSet集合中已经包含该元素，NSCountedSet不会接纳该元素，但会将该元素添加次数加一。
当程序从NSCountedSet中删除元素时，NSCountedSet只是将该元素的添加次数减一，只有当该元素添加次数变为0的时候，该元素才会真正的从NSCountedSet中删除。
它提供了countForObject：方法来获取指定元素的添加次数。
用下面的代码来演示其方法：
#import <Foundation/Foundation.h>
//定义一个函数，可以把NSSet集合转化为字符串
//方便我们调试观察结果
NSString *NSCollectionToString(id collection) {
NSMutableString *result = [NSMutableString stringWithString: @"["];
for (id obj in collection) {
[result appendString: [obj description]];
[result appendString: @","];
}
NSUInteger len = [result length];//获取字符串长度
[result deleteCharactersInRange: NSMakeRange(len - 1, 1)];//去除最后一个字符
[result appendString: @"]"];
return result;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSCountedSet *set = [NSCountedSet setWithObjects: @"疯狂iOS讲义", @"疯狂andro讲义", @"疯狂Ajax讲义", nil];
//向set里添加两次对应字符串
[set addObject: @"疯狂iOS讲义"];
[set addObject: @"疯狂iOS讲义"];
NSLog(@"%@", NSCollectionToString(set));
NSLog(@"疯狂iOS讲义的添加次数为：%ld", [set countForObject: @"疯狂iOS讲义"]);
//从set中删除对应字符串但不删完
[set removeObject: @"疯狂iOS讲义"];
NSLog(@"删除疯狂iOS讲义一次后的结果：%@", NSCollectionToString(set));
NSLog(@"删除疯狂iOS讲义一次后的添加次数：%ld", [set countForObject: @"疯狂iOS讲义"]);
//从set中删除对应字符串且删完
[set removeObject: @"疯狂iOS讲义"];
[set removeObject: @"疯狂iOS讲义"];
NSLog(@"删除疯狂iOS讲义3次后的结果：%@", NSCollectionToString(set));
NSLog(@"删除疯狂iOS讲义3次后的添加次数：%ld", [set countForObject: @"疯狂iOS讲义"]);
}
return 0;
}运行结果：
七、有序集合（NSOrderedSet和NSMutableOrderedSet）
NSOderedSet和NSMutableOrderedSet既具有NSSet集合的特征，又具有NSArray类似的功能。它有以下两个特点：
1、NSOrderedSet不允许元素重复。
2、NSOrderedSet可以保持元素的添加顺序，而且每个元素都有索引，可以根据索引来操作元素。
NSMutableOrderedSet是NSOrderedSet的子类，代表集合元素可变的有序集合。与前面一样，它可以增添，删除，替换，排序元素。
用代码演示其功能：
#import <Foundation/Foundation.h>
//定义一个函数，可以把NSSet集合转化为字符串
//方便我们调试观察结果
NSString *NSCollectionToString(id collection) {
NSMutableString *result = [NSMutableString stringWithString: @"["];
for (id obj in collection) {
[result appendString: [obj description]];
[result appendString: @","];
}
NSUInteger len = [result length];//获取字符串长度
[result deleteCharactersInRange: NSMakeRange(len - 1, 1)];//去除最后一个字符
[result appendString: @"]"];
return result;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
//创建集合时故意用重复的元素，可看到程序只会保留其中一个
NSOrderedSet *set = [NSOrderedSet orderedSetWithObjects: [NSNumber numberWithInt: 40], [NSNumber numberWithInt: 12], [NSNumber numberWithInt: -9], [NSNumber numberWithInt: 28], [NSNumber numberWithInt: 12], [NSNumber numberWithInt: 17], nil];
NSLog(@"%@", NSCollectionToString(set));
//根据索引获取元素
NSLog(@"set集合中的第一个元素：%@", [set firstObject]);
NSLog(@"set集合中的最后一个元素：%@", [set lastObject]);
NSLog(@"set集合中索引为2的元素：%@", [set objectAtIndex: 2]);
NSLog(@"28在set集合中的索引为：%ld", [set indexOfObject: [NSNumber numberWithInt:28]]);
//对集合进行过滤，获取元素值大于20的元素的索引
NSIndexSet *indexSet = [set indexesOfObjectsPassingTest: ^(id obj, NSUInteger idx, BOOL *stop) {
return (BOOL)([obj intValue] > 20);
}];
NSLog(@"set中元素值大于20的元素的索引为：%@", indexSet);
}
return 0;
}
运行结果：
八、字典（NSDictionary和NSMutableDictionary）
NSDictionary用于保存具有映射关系的数据，因此NSDictionary中保存着两组值，一组值用于保存key，另一组用于保存value。key和value都可以是任何引用类型的数据，Map的key不允许重复。
key和value之间存在单向一对一的关系，即通过指定的key，总能找到唯一的、确定的value。
NSDictionary包含了一个allKeys方法，用于返回NSDictionary中所有key组成的NSArray集合。
8.1 NSDictionary的功能和用法
NSDictionary由多组key-value对组成，因此创建NSDictionary时需要同时指定多组key、value对。NSDictionary分别提供了dictionary开头的类方法和init开头的实例方法。下面是创建NSDIctionary常见的几种方法：
| dictionary | 创建一个不包含任何key-value对的NSDictionary |
| dictionaryWithContentsOfFile：/initWithContentsOfFile： | 读取指定文件的内容，使用指定的文件的内容来初始化NSDictionary。该文件通常是由NSDictionary自己输出生成的 |
| dictionaryWithDictionary：/initWithDictionary： | 使用已有的NSDictionary包含的key-value对来初始化NSDictionary对象 |
| dictionaryWithObjects： forKeys：/initWithObjects： forKeys： | 使用两个NSArray分别指定key，value集合，可以创建包含多个key-value对的NSDictionary |
| dictionaryWithObject： forKey： | 使用单个key-value对来创建NSDictionary对象 |
| dictionaryWithObjectsAndKeys：/initWithObjectsAndKeys： | 调用该方法时，需要按照“value1,key1,value2,key2,...nil”的格式传入多个key-value对 |
以下是访问NSDictionary的几种方法：
在用代码演示上述功能之前，我们先写一个代码为NSDictionary扩展了一个print类别，在类别中扩展了一个print方法，用于打印NSDictionary中key-value对的详情：
这是接口部分：
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface NSDictionary (printf)
- (void) print;
@end
NS_ASSUME_NONNULL_END
实现部分：
#import "NSDictionary+printf.h"
@implementation NSDictionary (printf)
- (void) print {
NSMutableString *result = [NSMutableString stringWithString: @"{"];//创建一个可变字符串，初始化为左花括号
//快速枚举遍历调用该方法的对象的所有key元素
for (id key in self) {
[result appendString: [key description]];//向最开始的result对象后面追加访问到的key调用的改写过的description方法的返回值
[result appendString: @"="];
[result appendString: [self[key] description]];//使用下标访问法根据key获取对应的value
[result appendString: @","];
}
NSUInteger len = [result length];//获取字符串长度
[result deleteCharactersInRange: NSMakeRange(len - 2, 2)];//去掉字符串最后两个字符
[result appendString: @"}"];
NSLog(@"%@", result);
}
@end
上面的代码演示了NSDictionary的两个基本用法，程序可以使用快速枚举来遍历NSDictionary的所有key。除此之外，程序也可以根据key来获取对应的value。通过key来获取value有如下两种语法：
1、调用NSDictionary的objectForKey：方法即可根据key来获取对应的value。
2、直接使用下标法根据key来获取对应的value。使用这个语法获取时实际上就是调用NSDictionary的objectForKeyedSubscript：方法访问。
上面两个方法对应下面两个代码，它们的功能是相同的：
[dictionary objectForKey: key];
dictionary[key];然后又要用到之前写的那个FKUser类，这个类的接口和实现部分如下：
接口：
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface FKUser : NSObject
@property (nonatomic,copy) NSString *name;
@property (nonatomic,copy) NSString *pass;
- (id) initWithName: (NSString*) aName pass: (NSString*) aPass;//重写初始化方法
- (void) say: (NSString*) content;//定义一个say方法
@end
NS_ASSUME_NONNULL_END
实现：
#import "FKUser.h"
@implementation FKUser
@synthesize name;
@synthesize pass;
- (id) initWithName:(NSString *) aName pass:(NSString *) aPass {
if (self = [super init]) {
name = aName;
pass = aPass;
}
return self;
}
- (void) say: (NSString*) content {
NSLog(@"%@说：%@", self.name, content);
}
//重写自定义isEqual方法
- (BOOL) isEqual: (id)other {
if (self == other) {
return YES;
}
if ([other class] == FKUser.class) {
FKUser *target = (FKUser*) other;
return [self.name isEqualToString: target.name] && [self.pass isEqualToString: target.pass];
}
return NO;
}
//重写description方法
- (NSString*) description {
return [NSString stringWithFormat:@"<FKUser[name = %@, pass = %@>", self.name, self.pass];
}
@end
然后接下来的主函数就演示了刚刚所说的功能，主函数及运行结果：
#import <Foundation/Foundation.h>
#import "FKUser.h"
#import "NSDictionary+printf.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
//使用多个key-value对初始化创建NSDictionary对象
NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys: [[FKUser alloc] initWithName: @"晓美焰" pass: @"123"], @"one", [[FKUser alloc] initWithName: @"鹿目圆" pass: @"345"], @"two", [[FKUser alloc] initWithName: @"晓美焰" pass: @"123"], @"three", [[FKUser alloc] initWithName: @"巴麻美" pass: @"178"], @"four", [[FKUser alloc] initWithName: @"美树沙耶香" pass: @"155"], @"five", nil];
//对dict对象调用print方法，输出value和key的值
[dict print];
//调用count方法获得key-value对的数量
NSLog(@"dict包含%ld个key-value对", [dict count]);
//调用allKey方法获得所有的key值
NSLog(@"dict的所有key是：%@", [dict allKeys]);
//调用allKeysForObject方法获取指定value对应的全部key
NSLog(@"<FKUser[name = 晓美焰, pass = 123]>对应的所有的key为：%@", [dict allKeysForObject: [[FKUser alloc] initWithName: @"晓美焰" pass: @"123"]]);
//获取遍历dict所有value的枚举器
NSEnumerator *en = [dict objectEnumerator];
NSObject *value;
//使用枚举器遍历dict中的所有value
while (value = [en nextObject]) {
NSLog(@"%@", value);
}
//使用指定代码块来迭代执行该集合中所有key-value对
[dict enumerateKeysAndObjectsUsingBlock: ^(id key, id value, BOOL *stop) {
if (![key isEqual: @"two"]) {
NSLog(@"key的值为：%@", key);
[value say: @"圆神怎么你了"];
} else {
NSLog(@"key的值为：%@", key);
[value say: @"我怎么你了"];
}
}];
}
return 0;
}
8.2 对NSDictionary的key排序
NSDictionary还提供了方法对NSDictionary的所有key执行排序，这些方法执行完成后将返回排序完成后所有key组成的NSSArray。NSDictionary提供的排序方法如下：
1、keysSortedByValueUsingSelector:：根据NSDictionary的所有value的指定方法的返回值对key排序；调用value的该方法必须返回NSOrderedAscending（升序）、NSOrderedDesending（降序）、NSOrderedSame（同序）的三个值之一。
2、keysSortedByValueUsingComparator:：该方法使用指定的代码块来遍历key-value对，并根据执行结果返回NSOrderedAscending（升序）、NSOrderedDesending（降序）、NSOrderedSame（同序）的三个值之一来对NSDictionary的所有key排序。
3、keysSortedByValueWithOptions：usingComparator:：与前一个方法的功能相似，只是该方法可以传入一个额外的NSEnumerationOptions参数。
下面用代码演示：
继续要用到前面扩展的print方法，这里就不再写出来了
#import <Foundation/Foundation.h>
#import "NSDictionary+print.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
//使用多个key-value对创建NSDictionary
NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys: @"OC", @"one", @"Ruby", @"two", @"Python", @"three", @"Perl", @"four", nil];
[dict print];//调用print打印dict中所有的元素
//
NSArray *keyArr1 = [dict keysSortedByValueUsingSelector: @selector(compare:)];
NSLog(@"%@", keyArr1);
NSArray *keyArr2 = [dict keysSortedByValueUsingComparator: ^(id value1, id value2) {
if ([value1 length] > [value2 length]) {
return NSOrderedDescending;
}
if ([value1 length] < [value2 length]) {
return NSOrderedAscending;
}
return NSOrderedSame;
}];
NSLog(@"%@", keyArr2);
[dict writeToFile: @"myFile.txt" atomically: YES];
}
return 0;
}
8.3 对NSDictionary的key进行过滤
NSDictionary提供了以下两个过滤方法：
1、keysOfEntriesPassingTest:：使用代码块迭代处理NSDictionary中的每个key-value对，并对其进行过滤，该代码必须返回BOOL类型的值，只有当该代码返回YES的时候，该key才会被保留下来；该代码块可以接受三个参数，第一个参数表示正在迭代处理的key，第二个参数代表正在迭代处理的value，第三个参数代表是否需要继续迭代。
2、keysOfEntriesWithOptions: passingTest:：该方法的功能与前一个方法的功能基本相同，只是该方法额外传入一个NSEnumerationOptions选项参数。
代码演示：
#import <Foundation/Foundation.h>
#import "NSDictionary+print.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithInt: 89], @"Objective-C", [NSNumber numberWithInt: 69], @"Ruby", [NSNumber numberWithInt: 75], @"Python", [NSNumber numberWithInt: 109], @"Perl", nil];
[dict print];
//对NSDictionary的所有key过滤
NSSet *KeySet = [dict keysOfEntriesPassingTest: ^(id key, id value, BOOL *stop) {
//对NSDictionary的value进行比较
//当value的值大于80的key才会被保留
return (BOOL)([value intValue] > 80);
}];
NSLog(@"%@", KeySet);
}
return 0;
}
8.4 使用自定义类作为NSDictionary的key
如果程序打算使用自定义类作为key，需要满足以下要求：
1、该自定义类正确重写过isEqual和hash方法，即当两个对象通过isEqual：方法判断相等时它们的hash方法的返回值也相等。
2、该自定义类必须实现了copyWithZone：方法，该方法最好能返回对象的不可变副本。
以下是代码演示：
首先还是要有扩展的print，和上面一样就不写了
FKUser的接口和实现，在实现中，要重写isEqual和hash方法
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface FKUser : NSObject<NSCopying>
@property (nonatomic,copy) NSString *name;
@property (nonatomic,copy) NSString *pass;
- (id) initWithName: (NSString*) aName pass: (NSString*) aPass;
- (void) say: (NSString*) content;
@end
NS_ASSUME_NONNULL_END
#import "FKUser.h"
@implementation FKUser
@synthesize name;
@synthesize pass;
- (id) initWithName:(NSString *) aName pass:(NSString *) aPass {
if (self = [super init]) {
self.name = aName;
self.pass = aPass;
}
return self;
}
- (void) say: (NSString *) content {
NSLog(@"%@说:%@", self.name, content);
}
- (BOOL) isEqual: (id)object {
if (self == object) {
return YES;
}
if ([object class] == FKUser.class) {
FKUser *target = (FKUser*) object;
return [self.name isEqualToString: target.name] && [self.pass isEqualToString: target.pass];
}
return NO;
}
- (NSString*) description {
return [NSString stringWithFormat: @"<FKUSer[name = %@, pass = %@]>", self.name, self.pass];
}
- (id) copyWithZone: (NSZone *) zone {
NSLog(@"-----正在复制-----");
FKUser *newUser = [[[self class] allocWithZone: zone] init];
newUser.name = self.name;
newUser.pass = self.pass;
return newUser;
}
//重写hash方法，重写该方法的比较标准是：
//如果两个FKUser的name、pass相等，两个FKUser的Hash方法返回值相等
- (NSUInteger) hash {
NSUInteger nameHash = name == nil ? 0 : [name hash];
NSUInteger passHash = pass == nil ? 0 : [pass hash];
return nameHash * 31 + passHash;
}
@end
主函数及运行结果：
#import <Foundation/Foundation.h>
#import "NSDictionary+print.h"
#import "FKUser.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
FKUser *u1 = [[FKUser alloc] initWithName: @"晓美焰" pass: @"345"];
NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys: @"one", [[FKUser alloc] initWithName: @"鹿目圆" pass: @"123"], @"two", u1, @"three", [[FKUser alloc] initWithName: @"鹿目圆" pass: @"123"], @"four", [[FKUser alloc] initWithName: @"巴麻美" pass: @"178"], @"five", [[FKUser alloc] initWithName: @"美树沙耶香" pass: @"155"], nil];
u1.pass = nil;
[dict print];
}
return 0;
}
8.5 NSMutableDictionary的功能和用法
NSMutableDictionary继承了NSDictionary，代表一个key-value可变的NSDictionary集合。
用代码演示其方法：
#import <Foundation/Foundation.h>
#import "NSDictionary+print.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSMutableDictionary *dict = [NSMutableDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithInt: 89], @"疯狂iOS讲义", nil];
//使用下标法设置key-value对，由于NSDictionary中存在该key
//所以此处设置的value会覆盖之前的value
dict[@"疯狂iOS讲义"] = [NSNumber numberWithInt: 99];
[dict print];
NSLog(@"--再次添加key-value对--");
dict[@"疯狂XML讲义"] = [NSNumber numberWithInt: 69];
dict[@"疯狂Android讲义"] = [NSNumber numberWithInt: 69];
[dict print];
NSDictionary *dict2 = [NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithInt: 79], @"疯狂Ajax讲义", [NSNumber numberWithInt: 89], @"Struts 2.x权威指南", nil];
//将另一个NSDictionary中的key-value对添加到该集合中
[dict addEntriesFromDictionary: dict2];
[dict print];
//根据key来删除key-value对
[dict removeObjectForKey: @"Struts 2.x权威指南"];
[dict print];
}
return 0;
}
277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
