[Objective-C]大揭密-基础框架 Foundation 框架下的常用类介绍-CSDN博客

本文链接：https://blog.csdn.net/m0_74703932/article/details/130674115

[Objective-C]大揭密-基础框架 Foundation 框架下的常用类介绍

文章目录

[Objective-C]大揭密-基础框架 Foundation 框架下的常用类介绍

常用的类

字符串（NSString与NSMutableString）

NSString代表字符序列不可变的字符串，而NSMutable代表字符序列可变的字符串。

NSString字符串及功能

通过NSString，我们可以：

创建字符串
读取文件或网络URL来初始化字符串，或者将字符串写入文件或URL
获取字符串长度，即可获取字符串字符个数，也可获取字符串包括的字节个数
获取字符串中的字符或字节，即可获取指定位置的字符，也可获取指定范围的字符
获取字符串对应的C风格字符串
连接、分隔、查找、替换、比较字符串
对字符串中的字符进行大小写转换。

以下为代码展示

#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数组

unichar就是unsigned short的别名

程序将str2字符串的内容写入了底层的myFile.txt文件
因此，运行此程序就会发现该文件的运行目录下多了一个myFile.txt文件
该文件内容就是str2的字符串。

再来演示其他功能

#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!"];

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的代码中
修改字符串的时候，字符串所包含的字符序列本身就发生了改变
无需重新赋值

比如

[str1 appendString: @",iOS!"];

日期与时间

日期与时间（NSDate）

OC为处理日期、时间提供了NSDate、NSCalendar对象。

其中，NSDate对象代表日期与时间
OC既提供了类方法来创建NSDate对象，也提供了大量init开头的方法来初始化NSDate对象
创建NSDate的类方法和实例方法基本相似，只是类方法以date开头，实例方法以init开头。

日期格式器（NSDateFormatter）

NSDateFormatter代表一个日期格式器，它的作用就是完成NSDate和NSString之间的转换
。在进行转换时，我们首先需要创建一个NSDateFormatter对象，然后调用该对象的setDateStyle：、setTimeStyle：方法设置格式化日期、时间的风格
其中日期、时间风格支持以下几个枚举值：

NSDateFormatterNoStyle 不显示日期、时间的风格
NSDateFormatterShortStyle 显示“短”的日期、时间的风格
NSDateFormatterLongStyle 显示“长”的日期、时间的风格
NSDateFormatterMediumStyle 显示“中等”的日期、时间的风格
NSDateFormatterFullStyle 显示“完整”的日期、时间的风格

除了这几个枚举值，我们还可以通过调用setDateFormate：方法设置日期、时间的风格模版。

如果需要将NSDate转换为NSString，可以调用NSDateFormatter的stringFromDate：方法执行格式化即可
；如果需要将NSString转换为NSDate，可以调用NSDateFormatter的dateFromString：方法执行格式化即可

代码来

#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，它代表一个语言、国际环境，在不同的语言、国家环境下显示出来的字符串是不一样的。

日历（NSCalendar）与日期组件（NSDateComponents）

当需要将年、月、日的数值转换为NSDate的时候，或者从NSDate对象中获取其包含的年、月、日信息时，我们就需要将NSDate对象的各个字段数据分开提取。

为了能分开NSDate对象包含的各个字段数据，Foundation框架提供了NSCalendar对象，该对象包含了以下两个常用方法：

（NSDateComponents*）components： fromDate：：从NSDate提取年、月、日、时、分、秒各时间字段的信息。
dateFromComponents：（NSDateComponents*）comps：使用comps对象包含的年、月、日、时、分、秒各时间字段的信息来创建NSDate。

NSDateComponents对象是专门用于封装年、月、日、时、分、秒各时间字段的信息
只包含了对year、month、day、hour、minute、second、week、weekday等各字段的getter和setter方法

以下用代码演示

#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;
}

这里输出的星期的数字会比按照日历的星期数多一，是因为按西方他们是把周天当每周的第一天的

定时器（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方法即可。

Foundation对象复制

对象复制

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复制的副本是不可以被修改的

NSCopying和NSmutableCopying协议

当我们想将自定义类用上一节的两个方法复制副本时，我们可能会直接创建完对象后用”类名* 对象2 = [对象1 copy]；“这样的格式来复制副本，但实际上直接这样复制是不对的，会报错说找不到copyWithZone：方法，mutableCopy也是一样。因此我们可以看出，自定义类是不能直接调用这两个方法来复制自身的。

当程序调用copy/mutableCopy方法复制时，程序底层需要调用copyWithZone：/mutableCopyWithZone：方法来完成复制的工作，并返回这两个方法的值。因此为了保证可以复制，需要在自定义类的接口部分声明NSCopying/NSMutableCopying协议，然后再类的实现部分增加copyWithZone：/mutableCopyWithZone：方法

因此应该如下所示：

#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;
}

深复制和浅复制

首先用代码演示一下概念：

#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;
}

在上面的代码里,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对象的值就可以互相不干扰了。这就是深复制。

setter方法的复制选项

前面说到在合成setter和getter方法的时候可以使用copy指示符，该指示符就是指定当程序调用setter方法复制的时候，实际上是将传入参数的副本赋给程序的实例变量。

下面定义

#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）

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对象。

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;
}

对集合元素整体调用方法

    对于简单的调用集合中的元素的方法，可以通过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;
}

对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自身比较大小的方法是根据字符对应的编码来的。

    后两种方法通过调用代码块或者函数来比较大小，代码块相当于一个匿名函数，因此后面两种方式的本质是一样的，它们都可以通过自定义的比较规则来比较集合元素的大小。

使用枚举遍历器遍历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;
}

快速枚举（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;
}

可变数组(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;
}

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）

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;
}

NSSet判断集合元素重复的标准

    当向NSSet集合中存入一个元素时，NSSet会调用该对象的Hash方法来得到对象的hashCode值，然后根据该值决定该对象在底层Hash表中的存储位置，如果根据hashCode计算出该元素在底层Hash表中的存储位置已经不相同，那么系统自然的将它们存在不同的位置。

    如果两个元素的hashCode相同，接下来就要通过isEqual：方法判断两个元素是否相等，如果有两个元素通过isEqual：方法比较返回NO，NSSet依然认为它们不相等，NSSet会把它们都存在底层的Hash表的同一个位置，只是将在这个位置形成链，后面的元素添加失败。

    因此，HashSet集合判断两个元素相等的标准为：1、两个对象通过isEqual：方法比较返回YES；2、两个对象的hash方法返回值相等。

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;
}

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;
}