OC笔记之foundation框架

OC学习笔记（三）

文章目录

OC学习笔记（三）
- 常用Foundation框架结构体
- - NSRange
  - - NSRange结构体的定义
    - 定义 `NSRange` 的方法
    - 打印Range的相关信息
    - NSRange的实际运用
    - 查找子字符串返回NSRange结构体
  - NSPoint
  - NSRect
- NSString
- - NSString的创建
  - NSString的导出
  - NSstring的常用方法
  - - **转换为大写或小写：**
    - **首字母大写或小写：**
  - 查找
  - - - isEqualToString
      - compare
      - 前缀查找
      - stringByReplacingOccurrencesOfString
    - 字符串的截取
    - 分隔字符串
    - NSString与路径相关的方法
- NSDateComponents
- NSArray
- - 创建 NSArray 的方法
  - 访问 NSArray 中的元素
  - 在数组中添加新元素
  - 对集合元素整体调用方法
  - - makeObjectsPerformSelector:调用元素方法
    - 隐式遍历
  - NSArray的排序
  - 枚举器遍历集合元素
  - 快速枚举
- mutableArray
- NSSet
- - NSSet判断重复的标准
  - NSOrderedSet
- NSDictionary
- NSMutableDictionary

常用Foundation框架结构体

NSRange

NSRange结构体的定义

在 Objective-C 中，NSRange 结构体定义如下：

typedef struct _NSRange {
    NSUInteger location;
    NSUInteger length;
  //相当于unsigned long
} NSRange;

这个结构体是用来表示一个事物的范围，通常是字符串里的字符范围和集合里的元素范围。

location表示范围的起始位置
length表示该范围元素的个数

定义 `NSRange` 的方法

直接赋值方式：

NSRange range;
range.location = 0;
range.length = 5;

使用 NSMakeRange 函数：

NSRange range = NSMakeRange(0, 5);

使用结构体初始化器：

NSRange range = {0, 5};

使用属性初始化器：

NSRange range = {.location = 0, .length = 5};

这些方法都可以用来定义一个 NSRange 结构体，表示一段连续的范围。在实际使用时，可以根据具体情况选择最适合的方式来定义 NSRange。

打印Range的相关信息

NSStringFromRange 是 Foundation 框架中定义的一个函数，用于将 NSRange 结构体转换为字符串表示形式。它接受一个 NSRange 结构体作为参数，并返回一个表示该范围的字符串。

函数原型如下：

NSString *NSStringFromRange(NSRange range);

使用示例如下：

NSRange range = NSMakeRange(3, 7);
NSString *rangeString = NSStringFromRange(range);
NSLog(@"Range: %@", rangeString);

输出结果为：

Range: {3, 7}

这表示范围的起始位置为 3，长度为 7。NSStringFromRange 函数可以方便地将 NSRange 结构体转换为可读性较好的字符串表示形式，便于在调试或打印输出时使用。

NSRange的实际运用

下面是一个使用 NSRange 的例子，用于从一个字符串中提取子串：

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSString *originalString = @"Hello, World!";
        
        // 定义一个 NSRange 结构体，表示从第 7 个字符开始（索引从 0 开始计数），长度为 5 的子串范围
        NSRange range = NSMakeRange(7, 5);
        
        // 从原始字符串中获取指定范围的子串
        NSString *subString = [originalString substringWithRange:range];
        
        NSLog(@"Original String: %@", originalString);
        NSLog(@"Substring: %@", subString);
    }
    return 0;
}

在这个例子中，原始字符串是 “Hello, World!”。我们通过定义一个 NSRange 结构体，指定从第 7 个字符开始（‘W’）的 5 个字符长度的范围。然后使用 substringWithRange: 方法从原始字符串中获取指定范围的子串。最后，打印输出原始字符串和提取出的子串。

运行结果为：

Original String: Hello, World!
Substring: World

可以看到，成功从原始字符串中提取出了 “World” 这个子串。

查找子字符串返回NSRange结构体

rangeOfString 是 NSString 类中的一个方法，用于在字符串中查找指定子字符串的范围。该方法的基本语法如下：

- (NSRange)rangeOfString:(NSString *)aString;

其中，aString 是要查找的子字符串。如果找到了子字符串，则返回该子字符串在原始字符串中的范围（即 NSRange 结构），否则返回 {NSNotFound, 0}。

这个方法还有一个可选参数 options，用于指定搜索的选项。常用的选项包括：

NSCaseInsensitiveSearch：忽略大小写进行搜索。
NSLiteralSearch：进行字面搜索，不考虑字符的转义序列（即忽略\n之类的内容）。

如果需要指定选项，可以使用下面的方法：

- (NSRange)rangeOfString:(NSString *)aString options:(NSStringCompareOptions)mask;

举个例子，假设我们有一个字符串：

NSString *str = @"Hello, World!";

我们想要查找子字符串 "World" 在 str 中的位置，可以这样使用 rangeOfString 方法：

NSRange range = [str rangeOfString:@"World"];
if (range.location != NSNotFound) {
    NSLog(@"Found at location %lu, length %lu", range.location, range.length);
} else {
    NSLog(@"Not found");
}

这段代码会输出 "Found at location 7, length 5"，因为子字符串 "World" 在原始字符串中的起始位置是第 7 个字符，长度为 5 个字符。

NSPoint

NSPoint 是 Foundation 框架中定义的一个结构体，用于表示平面上的一个点的坐标。NSPoint 结构体包含两个成员变量：x 和 y，分别表示点的横坐标和纵坐标。在 macOS 和 iOS 开发中，NSPoint 结构体经常用于表示视图或图形中的坐标点。

在 Objective-C 中，NSPoint 的定义如下：

typedef struct _NSPoint {
    CGFloat x;
    CGFloat y;
} NSPoint;

其中，CGFloat 是一个与平台相关的浮点数类型，用于表示屏幕上的坐标点。

使用示例：

NSPoint point = NSMakePoint(10.0, 20.0);
NSLog(@"Point: (%.1f, %.1f)", point.x, point.y);

在这个示例中，我们使用 NSMakePoint 函数创建了一个 NSPoint 结构体，表示坐标为 (10.0, 20.0) 的点。然后，使用 NSLog 函数打印输出了该点的坐标。

NSStringFromPoint 是 Foundation 框架中定义的一个函数，用于将 NSPoint 结构体表示的点坐标转换为字符串表示形式。它接受一个 NSPoint 结构体作为参数，并返回一个表示该点坐标的字符串。

函数原型如下：

NSString *NSStringFromPoint(NSPoint point);

使用示例如下：

NSPoint point = NSMakePoint(10.0, 20.0);
NSString *pointString = NSStringFromPoint(point);
NSLog(@"Point: %@", pointString);

NSPoint 结构体在 macOS 和 iOS 开发中经常用于表示视图或图形的坐标点，以及处理与用户界面相关的布局和绘图操作。

NSSize

NSSize 是 Foundation 框架中定义的一个结构体，用于表示平面上的一个区域的尺寸。NSSize 结构体包含两个成员变量：width 和 height，分别表示区域的宽度和高度。在 macOS 和 iOS 开发中，NSSize 结构体经常用于表示视图或图形中的区域尺寸。

在 Objective-C 中，NSSize 的定义如下：

typedef struct _NSSize {
    CGFloat width;//double类型
    CGFloat height;
} NSSize;

其中，CGFloat 是一个与平台相关的浮点数类型，用于表示屏幕上的尺寸。

使用示例：

NSSize size = NSMakeSize(100.0, 50.0);
NSLog(@"Size: %.1f x %.1f", size.width, size.height);

在这个示例中，我们使用 NSMakeSize 函数创建了一个 NSSize 结构体，表示宽度为 100.0，高度为 50.0 的区域尺寸。然后，使用 NSLog 函数打印输出了该区域尺寸的宽度和高度。

NSSize 结构体在 macOS 和 iOS 开发中经常用于表示视图或图形的尺寸，以及处理与用户界面相关的布局和绘图操作。

NSRect

NSRect 是 Foundation 框架中定义的一个结构体，用于表示矩形的位置和尺寸。NSRect 结构体包含了一个 NSPoint 结构体类型的成员变量 origin 和一个 NSSize 结构体类型的成员变量 size。origin 表示矩形的左上角顶点的坐标，而 size 表示矩形的宽度和高度。

在 Objective-C 中，NSRect 的定义如下：

typedef struct _NSRect {
    NSPoint origin;
    NSSize size;
} NSRect;

NSRect 结构体在 macOS 和 iOS 开发中经常用于表示视图或图形的位置和尺寸，以及进行布局和绘制操作。可以通过 NSMakeRect 函数来创建一个 NSRect 结构体，也可以通过 NSRectMake 宏来快速创建一个 NSRect 结构体。

使用示例：

NSRect rect = NSMakeRect(10.0, 20.0, 100.0, 50.0);
NSLog(@"Rect: origin(%.1f, %.1f), size(%.1f x %.1f)", rect.origin.x, rect.origin.y, rect.size.width, rect.size.height);

在这个示例中，我们使用 NSMakeRect 函数创建了一个 NSRect 结构体，表示左上角顶点坐标为 (10.0, 20.0)，宽度为 100.0，高度为 50.0 的矩形。然后，使用 NSLog 函数打印输出了该矩形的位置和尺寸信息。

NSString

NSString的创建

NSString 的创建方式有以下几种：

使用字符串字面量（String Literals）创建：
```
NSString *str = @"Hello, World!";
```
这是一种最常见的方式，直接将字符串文字放在引号中，编译器会在编译时将其转换为 NSString 对象。这种方式创建的字符串是不可变的。
使用类方法 stringWithFormat: 创建：
```
NSString *str = [NSString stringWithFormat:@"Today is %@.", @"Monday"];
```
这种方式允许你使用格式化字符串来创建 NSString 对象。可以使用类似于 printf 的格式说明符来插入变量值。创建的字符串是不可变的。
使用 initWithFormat: 方法创建：
```
NSString *str = [[NSString alloc] initWithFormat:@"The value of pi is %.2f", 3.14];
```
这是通过调用初始化方法手动创建 NSString 对象，并使用格式化字符串来设置其内容。创建的字符串是不可变的。
使用字符串常量方法 stringWithCString:encoding: 创建：
```
const char *cString = "Hello, World!";
NSString *str = [NSString stringWithCString:cString encoding:NSUTF8StringEncoding];
```
这种方式允许你将 C 语言风格的字符串转换为 NSString 对象。你需要指定编码方式，以便 NSString 正确地解析 C 字符串中的字符。创建的字符串是不可变的。
使用 init 方法创建：
```
NSString *str = [[NSString alloc] initWithString:@"Hello, World!"];
```
这种方式使用 initWithString: 方法直接将另一个 NSString 对象的内容复制到新创建的 NSString 对象中。创建的字符串是不可变的。
使用 initWithUTF8String: 方法创建：
```
const char *cString = "Hello, World!";
NSString *str = [[NSString alloc] initWithUTF8String:cString];
```
这种方式类似于 stringWithCString:encoding: 方法，但是使用了 UTF-8 编码。创建的字符串是不可变的。

当从文件中读取文本时，你可以使用 NSString 类的 stringWithContentsOfFile:encoding:error: 方法。

NSError *error = nil;
NSString *filePath = @"/path/to/your/file.txt";
NSString *content = [NSString stringWithContentsOfFile:filePath
                                               encoding:NSUTF8StringEncoding
                                                  error:&error];
if (content == nil) {
    NSLog(@"Error reading file: %@", error);
} else {
    NSLog(@"File content: %@", content);
}

这段代码会尝试从指定路径的文件中读取文本内容，并以 UTF-8 编码解析。如果读取失败，会在 error 中记录错误信息。

此外我们还可以通过网络请求获取网页的内容作为字符串

NSString的导出

在我们使用oc的过程之中，对于字符串

以下是一个示例，将字符串写入文件：

NSString *myString = @"Hello, World!";
NSString *filePath = @"/path/to/file.txt";

BOOL success = [myString writeToFile:filePath atomically:YES encoding:NSUTF8StringEncoding error:nil];
if (success) {
    NSLog(@"String exported to file successfully.");
} else {
    NSLog(@"Failed to export string to file.");
}

在上述示例中，writeToFile:atomically:encoding:error:方法将字符串myString写入到指定路径filePath的文件中。encoding参数指定了字符串的编码方式，这里使用UTF-8编码，编码指定错误也会进行报错。error参数用于传入错误信息，如果写入文件失败，可以通过该参数获取错误信息。

当atomically参数设置为YES时，文件写入操作是原子的。这意味着在写入文件之前，首先会创建一个临时文件，然后将数据写入临时文件。只有当写入操作完成后，才会将临时文件移动到目标位置。这样可以确保在写入过程中不会中断或出现错误导致文件数据不完整。如果写入过程中发生错误，将不会更新目标文件，原始文件保持不变。

当atomically参数设置为NO时，文件写入操作是非原子的。数据直接写入目标文件，如果在写入过程中出现错误或中断，可能会导致目标文件处于不完整或不一致的状态。

通常情况下，建议将atomically参数设置为YES，以确保文件写入的原子性和数据完整性。只有在特殊情况下，需要手动控制文件的写入过程，才会将atomically参数设置为NO。

NSstring的常用方法

转换为大写或小写：

使用 uppercaseString 方法将字符串转换为大写，使用 lowercaseString 方法将字符串转换为小写。

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool{
        NSString *str1 = @"Hello World!";
        NSString *upper = [str1 uppercaseString];
        NSString *lower = [str1 lowercaseString];
        NSLog(@"%@\n%@",upper,lower);
    }
    return 0;
}

首字母大写或小写：

使用 capitalizedString 方法将字符串的首字母转换为大写。

NSString *originalString = @"hello, world!";
NSString *capitalizedString = [originalString capitalizedString];

比较时忽略大小写：

使用 caseInsensitiveCompare: 方法进行字符串比较时忽略大小写。
```
NSString *string1 = @"Hello";
NSString *string2 = @"hello";
NSComparisonResult result = [string1 caseInsensitiveCompare:string2];
if (result == NSOrderedSame) {
    NSLog(@"字符串相同");
} else {
    NSLog(@"不相同");
}
```
查找

不忽略大小写

isEqualToString
isEqualToString:是NSString类的一个方法，用于比较字符串内容是否相等。

方法签名如下：
```
- (BOOL)isEqualToString:(NSString *)aString;
```
参数aString是要与当前字符串进行比较的另一个字符串。

返回值是一个BOOL类型，表示比较结果，如果两个字符串相等，则返回YES；否则返回NO。

使用示例：
```
NSString *string1 = @"Hello";
NSString *string2 = @"Hello";
NSString *string3 = @"World";

BOOL isEqual1 = [string1 isEqualToString:string2];
BOOL isEqual2 = [string1 isEqualToString:string3];

NSLog(@"isEqual1: %d", isEqual1); // 输出：isEqual1: 1
NSLog(@"isEqual2: %d", isEqual2); // 输出：isEqual2: 0
```
在上述示例中，我们创建了三个字符串对象：string1、string2和string3。然后，通过调用isEqualToString:方法来比较字符串是否相等。isEqual1存储了string1和string2的比较结果，由于两个字符串内容相同，所以返回YES。isEqual2存储了string1和string3的比较结果，由于两个字符串内容不同，所以返回NO。

注意：isEqualToString:方法是区分大小写的。
compare

、compare:是NSString类的一个方法，用于比较字符串的顺序。

方法签名如下：
```
- (NSComparisonResult)compare:(NSString *)string;
```
参数string是要与当前字符串进行比较的另一个字符串。

返回值是一个枚举类型NSComparisonResult，表示比较结果的三种可能取值：
- NSOrderedAscending：当前字符串在参数字符串之前。
- NSOrderedSame：当前字符串与参数字符串相同。
- NSOrderedDescending：当前字符串在参数字符串之后。
示例
```
NSString *string1 = @"apple";
NSString *string2 = @"banana";
NSString *string3 = @"apple";

NSComparisonResult result1 = [string1 compare:string2];
NSComparisonResult result2 = [string1 compare:string3];

if (result1 == NSOrderedAscending) {
    NSLog(@"string1 大于 string2");
} else if (result1 == NSOrderedSame) {
    NSLog(@"string1 相同 string2");
} else if (result1 == NSOrderedDescending) {
    NSLog(@"string1 小于 string2");
}

if (result2 == NSOrderedAscending) {
    NSLog(@"string1 大于 string3");
} else if (result2 == NSOrderedSame) {
    NSLog(@"string1 等于 string3");
} else if (result2 == NSOrderedDescending) {
    NSLog(@"string1 小于 string3");
}
```
得到结果为
```
string1 大于 string2
string1 等于 string3
```
compare在用于排序起到十分关键的作用

查找时忽略大小写

使用 rangeOfString:options: 方法进行字符串查找时忽略大小写。方法用于在字符串中查找指定子字符串的位置，并返回其在原字符串中的范围。如果找到了子字符串，则返回其范围；如果未找到，则返回 {NSNotFound, 0}。

对于此函数来说，默认是区分大小写的，如果想要忽略大小写进行查找，可以使用 options 参数来指定 NSCaseInsensitiveSearch 选项。

另外options还能规定向前查找或者向后查找，由于默认为从前向后查找，当我们需要从后往前查找时，可以使用NSBackwardsSearch。

以下即为例子：
```
#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool{
        NSString *str1 = @"hello World!";
        NSString *str2 = @"world!";
        NSString *str3 = @"hello World,hello!";
        NSRange result = [str1 rangeOfString:str2 options:NSCaseInsensitiveSearch];
        NSRange range = [str3 rangeOfString:@"hello" options:NSBackwardsSearch];
        NSLog(@"%@",NSStringFromRange(range));
        
        if(result.location != NSNotFound) {
            NSLog(@"找到");
        } else {
            NSLog(@"找不到");
        }
    }
    return 0;
}
```
前缀查找

hasPrefix:是NSString类的一个方法，用于检查字符串是否以指定的前缀开头。

方法签名如下：
```
- (BOOL)hasPrefix:(NSString *)prefix;
```
参数prefix是要检查的前缀字符串。

返回值是一个BOOL类型，如果当前字符串以指定的前缀开头，则返回YES；否则返回NO。

使用示例：
```
NSString *string = @"Hello, World!";

BOOL hasPrefix1 = [string hasPrefix:@"Hello"];
BOOL hasPrefix2 = [string hasPrefix:@"Hi"];

NSLog(@"hasPrefix1: %d", hasPrefix1); // 输出：hasPrefix1: 1
NSLog(@"hasPrefix2: %d", hasPrefix2); // 输出：hasPrefix2: 0
```
在上述示例中，我们创建了一个字符串对象string，然后使用hasPrefix:方法检查字符串是否以指定的前缀开头。hasPrefix1存储了检查"Hello"前缀的结果，由于字符串以"Hello"开头，所以返回YES。hasPrefix2存储了检查"Hi"前缀的结果，由于字符串不以"Hi"开头，所以返回NO。

hasPrefix:方法常用于判断字符串的开头，例如判断URL是否以特定协议头开头，或者判断文件名是否以特定文件类型的前缀开头等。

注意：这个hasPerfix是区分大小写的，如果需要不区分大小写，可以在此方法后添加一个可选参数mask

方法签名如下：
```
- (BOOL)hasPrefix:(NSString *)prefix options:(NSStringCompareOptions)mask;
```
参数prefix是要检查的前缀字符串，mask是一个选项参数，用于设置匹配的选项。

常用的选项参数包括：
- NSCaseInsensitiveSearch：不区分大小写。
- NSLiteralSearch：执行精确的字符匹配，不考虑本地化的影响。
- NSDiacriticInsensitiveSearch：忽略字符串中的重音符号。
```
NSString *string = @"Hello, World!";

BOOL hasPrefix1 = [string hasPrefix:@"hello" options:NSCaseInsensitiveSearch];
BOOL hasPrefix2 = [string hasPrefix:@"hi"];

NSLog(@"hasPrefix1: %d", hasPrefix1); // 输出：hasPrefix1: 1
NSLog(@"hasPrefix2: %d", hasPrefix2); // 输出：hasPrefix2: 0
```
在上述示例中，我们使用hasPrefix:options:方法，并设置选项参数为NSCaseInsensitiveSearch，这样在前缀匹配时会忽略大小写。hasPrefix1存储了检查"hello"前缀的结果，由于字符串以"Hello"开头，忽略大小写后匹配成功，所以返回YES。hasPrefix2存储了检查"hi"前缀的结果，由于字符串不以"hi"开头，所以返回NO。

通过提供适当的选项参数，你可以控制前缀匹配时是否忽略大小写、重音符号等，以满足具体的匹配需求。

替换时忽略大小写：

stringByReplacingOccurrencesOfString

stringByReplacingOccurrencesOfString:withString:options:range:是NSString类的一个方法，用于在字符串中替换所有匹配的子字符串。

它的详细用法如下：
```
- (NSString *)stringByReplacingOccurrencesOfString:(NSString *)target withString:(NSString *)replacement options:(NSStringCompareOptions)options range:(NSRange)searchRange;
```
参数说明：
- target：要被替换的目标子字符串。
- replacement：用于替换目标子字符串的字符串。
- options：指定替换的选项，如大小写敏感性、搜索范围等。
- searchRange：指定在哪个范围内进行搜索和替换。
```
NSString *originalString = @"Hello, World!";
NSString *replacedString = [originalString stringByReplacingOccurrencesOfString:@"hello" withString:@"Hi" options:NSCaseInsensitiveSearch range:NSMakeRange(0, originalString.length)];
```

这些方法可以根据你的需求来处理字符串的大小写，从而实现不同的功能。

字符串的截取

1. substringFromIndex:：从指定索引截取到字符串末尾。

NSString *originalString = @"Hello, World!";
NSString *substring = [originalString substringFromIndex:7];
NSLog(@"%@", substring); // 输出 "World!"

在上述示例中，我们使用substringFromIndex:方法从索引7开始截取originalString字符串的子字符串。结果是将从索引7开始的字符及其之后的字符截取出来，即"World!"。

2. substringToIndex:：从字符串开头截取到指定索引的前一个位置。

NSString *originalString = @"Hello, World!";
NSString *substring = [originalString substringToIndex:5];
NSLog(@"%@", substring); // 输出 "Hello"

在这个示例中，我们使用substringToIndex:方法从originalString字符串的开头截取子字符串。指定索引5表示截取到索引4的位置，即"Hello"。

3. substringWithRange:：使用NSRange结构截取指定范围的字符。

NSString *originalString = @"Hello, World!";
NSRange range = NSMakeRange(7, 5); // 从索引7开始，截取5个字符
NSString *substring = [originalString substringWithRange:range];
NSLog(@"%@", substring); // 输出 "World"

在这个示例中，我们使用NSRange结构定义了一个范围，从索引7开始，截取5个字符。然后，我们使用substringWithRange:方法来截取originalString字符串中指定范围的子字符串。结果是截取了"World"这个子字符串。

这些示例演示了如何在Objective-C中使用这些字符串截取方法来获取所需的子字符串。你可以根据具体的需求和字符串内容，调整索引和范围参数来截取不同的子字符串。

分隔字符串

componentsSeparatedByString:是一个用于字符串分割的方法，它将一个字符串根据指定的分隔符拆分成一个数组。下面是一个示例：

NSString *originalString = @"aa,bb,cc";
NSArray *components = [originalString componentsSeparatedByString:@","];
NSLog(@"%@", components);

在上述示例中，我们有一个包含逗号分隔符的原始字符串originalString，即"apple,banana,cherry"。然后，我们使用componentsSeparatedByString:方法以逗号为分隔符将字符串拆分成一个数组。

拆分后的数组components将包含三个元素，分别是"apple"、“banana"和"cherry”。最后，我们使用NSLog打印components数组的内容，输出结果为：

(
    aa,
    bb,
    cc
)

通过调用componentsSeparatedByString:方法，你可以根据指定的分隔符将字符串拆分成多个子字符串，并将它们存储在数组中。这在处理具有特定格式的字符串时非常有用，例如CSV文件中的行数据或用逗号分隔的标签列表等。

NSString与路径相关的方法

在Objective-C中，NSString类提供了一些与路径相关的方法，用于处理文件路径的创建、拼接、扩展名获取等操作。下面是一些常用的与路径相关的方法：

路径创建和拼接：
- stringByAppendingPathComponent:：将路径字符串与指定的路径组件拼接成一个新的路径字符串。
- stringByAppendingPathExtension:：将路径字符串的扩展名部分替换为指定的扩展名，生成新的路径字符串。
路径获取和提取：
- lastPathComponent：获取路径字符串中的最后一个组件（文件名或目录名）。
- pathExtension：获取路径字符串中的扩展名部分。
- stringByDeletingLastPathComponent：删除路径字符串中的最后一个组件，并生成新的路径字符串。
- stringByDeletingPathExtension：删除路径字符串的扩展名部分，并生成新的路径字符串。
路径判断和比较：
- isAbsolutePath：检查路径字符串是否是绝对路径。
- isEqualToString:：判断两个路径字符串是否相等。
- pathComponents：将路径字符串拆分为组件，并返回一个数组。
路径转换和规范化：
- stringByStandardizingPath：规范化路径字符串，去除多余的斜杠和相对路径符号。

下面是一些示例，展示如何使用这些方法进行路径操作：

NSString *path = @"/Users/username/Documents/file.txt";

// 获取文件名和扩展名
NSString *fileName = [path lastPathComponent];
NSString *extension = [path pathExtension];
NSLog(@"File Name: %@", fileName); // 输出 "file.txt"
NSLog(@"Extension: %@", extension); // 输出 "txt"

//用给定的array内容拼成路径
NSArray *components = @[@"Users", @"username", @"Documents", @"file.txt"];
NSString *filePath = [NSString pathWithComponents:components];
NSLog(@"%@", filePath); // 输出 /Users/username/Documents/file.txt

//将路径分隔为array
NSString *filePath = @"/Users/username/Documents/file.txt";
NSArray *pathComponents = [filePath pathComponents];
NSLog(@"%@", pathComponents);

// 创建新路径
NSString *newPath = [path stringByAppendingPathComponent:@"subfolder/newfile.txt"];
NSLog(@"New Path: %@", newPath); // 输出 "/Users/username/Documents/file.txt/subfolder/newfile.txt"

// 删除最后一个组件
NSString *parentPath = [path stringByDeletingLastPathComponent];
NSLog(@"Parent Path: %@", parentPath); // 输出 "/Users/username/Documents"

// 替换扩展名
NSString *newExtension = [path stringByDeletingPathExtension];
newExtension = [newExtension stringByAppendingPathExtension:@"doc"];
NSLog(@"New Extension: %@", newExtension); // 输出 "/Users/username/Documents/file.doc"

通过使用这些路径相关的方法，你可以方便地创建、拼接、提取和修改文件路径字符串，以及进行路径的规范化和判断。这些方法在处理文件路径和文件系统操作时非常有用。

NSDateComponents

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSDate *date1 = [NSDate date];
        NSCalendar *gregorian = [[NSCalendar alloc] initWithCalendarIdentifier:NSCalendarIdentifierGregorian];
        unsigned Unitflag = NSCalendarUnitYear | NSCalendarUnitMonth | NSCalendarUnitDay;
        NSDateComponents* comp = [gregorian components:Unitflag fromDate:date1];
        NSLog(@"%ld",comp.year);
        NSLog(@"%ld",comp.month);
        NSLog(@"%ld",comp.day);
    }
    return 0;
}

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 创建一个NSDateComponents对象，并设置年、月、日
        NSDateComponents *components = [[NSDateComponents alloc] init];
        [components setYear:2024];
        [components setMonth:5];
        [components setDay:6];
        
        // 创建一个NSCalendar对象
        NSCalendar *calendar = [NSCalendar currentCalendar];
        
        // 从NSDateComponents对象中获取NSDate对象
        NSDate *date = [calendar dateFromComponents:components];
        
        // 打印结果
        NSLog(@"%@", date);
    }
    return 0;
}

NSArray

在将元素添加到数组array之中时，该元素的引用计数器有自动加一

创建 NSArray 的方法

NSArray给出来类方法和实例方法来创建NSArray，两种传入的参数大体相似，只是类方法以NSArray开头，而实例方法是使用init。

**使用字面量语法：**用化简语法来创建NSArray形式如下
```
NSArray *array = @[@"Apple", @"Banana", @"Orange"];
```
**使用 arrayWithObjects:/initWithObjects 方法：**创建N个包含指定元素的NSArray
```
NSArray *array = [NSArray arrayWithObjects:@"Apple", @"Banana", @"Orange", nil];
```
注意：在使用 arrayWithObjects: 方法创建数组时，需要以 nil 结尾。这一个nil实际只是声明数组结束，并不会存入NSArray。
使用 arrayWithContentsOfFile:/initWithContentsOfFile: 方法：
```
NSString *path = [[NSBundle mainBundle] pathForResource:@"Data" ofType:@"plist"];
NSArray *array = [NSArray arrayWithContentsOfFile:path];
```
这种方法会从指定的文件中读取内容，并创建一个包含文件内容的数组。

根据你的需求和数据来源，选择合适的方法来创建 NSArray。

访问 NSArray 中的元素

要通过索引访问 NSArray 中的元素，可以使用下标语法或者提供的方法。

下标语法：

使用下标语法可以直接通过索引来访问数组中的元素。索引从 0 开始，依次递增。示例代码如下：
```
NSArray *array = @[@"Apple", @"Banana", @"Orange"];
NSString *element = array[0]; // 获取第一个元素
NSLog(@"%@", element); // 输出：Apple
```
对于下标语法来说，实质上就是调用NSArray之中的objectAtIndexSubscript方法。
objectAtIndex: 方法：

使用 objectAtIndex: 方法可以通过索引来获取数组中的元素。示例代码如下：
```
NSArray *array = @[@"Apple", @"Banana", @"Orange"];
NSString *element = [array objectAtIndex:0]; // 获取第一个元素
NSLog(@"%@", element); // 输出：Apple
```
这个方法也可以用来获取数组中的其他元素，只需要传入相应的索引即可。

可以看出相对于第一种访问方式来说，第二种的访问方式还是较为麻烦的。
firstObject 和 lastObject 方法：

firstObject 方法返回数组中的第一个元素，如果数组为空则返回 nil。
lastObject 方法返回数组中的最后一个元素，如果数组为空则返回 nil。

示例代码如下：

objective
Copy code
NSArray *array = @[@"Apple", @"Banana", @"Orange"];
NSString *firstElement = array.firstObject; // 获取第一个元素
NSString *lastElement = array.lastObject; // 获取最后一个元素

要找到对象在数组中的索引，可以使用 indexOfObject: 方法。

NSArray *array = @[@"apple", @"banana", @"orange", @"grape"];
NSString *object = @"orange";

NSUInteger index = [array indexOfObject:object];
if (index != NSNotFound) {
    NSLog(@"对象在索引 %lu 处找到", (unsigned long)index);
} else {
    NSLog(@"对象未找到");
}

在这个示例中，我们使用 indexOfObject: 方法来查找对象 "orange" 在数组 array 中的索引。如果找到了对象，将会打印出索引值（在这个例子中为 2），否则打印出 “对象未找到”。

在数组中添加新元素

使用 arrayWithArray: 方法：

NSArray *originalArray = @[@"Apple", @"Banana", @"Orange"];
NSArray *array = [NSArray arrayWithArray:originalArray];

这种方法会创建一个包含原始数组所有元素的新数组。

使用 arrayByAddingObject: 方法：
```
NSArray *originalArray = @[@"Apple", @"Banana", @"Orange"];
NSArray *array = [originalArray arrayByAddingObject:@"Grapes"];
```
这种方法会创建一个包含原始数组所有元素以及指定对象的新数组。

以上的两种方法，都不是直接改变NSArray的对象，而是重新创建对象，并将指针赋给他们所属的array指针。

对集合元素整体调用方法

makeObjectsPerformSelector:依次调用NSAray集合中每个元素的指定方法，该方法需要传入一个SEL 参数，用于指定调用哪个方法。

makeObj ectsPerformSelector:withObject:依次调用NSArray 集合中每个元素的指定方法，该方法的第一个SEL 参数用于指定调用哪个方法，第二个参数用于调用集合元素的方法时传入参数。

makeObjectsPerformSelector:调用元素方法

可以使用 makeObjectsPerformSelector: 方法来对集合中的每个对象执行指定的方法。通过调用 makeObjectsPerformSelector: 方法，并传入要执行的方法的选择器（selector），集合中的每个对象都会自动调用这个方法。需要注意的是，被调用的方法必须是无参的，并且返回类型为 void。如果我们调用的方法有传入参数，那么可以使用 makeObjectsPerformSelector:withObject: 方法来对集合中的每个对象执行带有参数的方法。

下面是一个示例，展示如何使用 makeObjectsPerformSelector: 方法

#import <Foundation/Foundation.h>


@interface JCUser : NSObject
@property (nonatomic, copy) NSString* name;
@property (nonatomic, copy) NSString* password;
-(id) initWithName : (NSString*)aname password: (NSString*)apassword;
-(void) say :(NSString*) content;
@end

---------------------------------------------------------------------------------------------------------
#import "JCUser.h"
@implementation JCUser
-(id) initWithName : (NSString*)aname password: (NSString*)apassword {
    if(self = [super init]) {
        self->_name = aname;
        self->_password = apassword;
    }
    return self;
}
-(void) say :(NSString*) content {
    NSLog(@"%@说，%@",self->_name, content);
}
@end
---------------------------------------------------------------------------------------------------------
#import <Foundation/Foundation.h>
#import "JCUser.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSArray* array = @[
        [[JCUser alloc] initWithName:@"aa" password:@"123"],
        [[JCUser alloc] initWithName:@"bb" password:@"234"],
        [[JCUser alloc] initWithName:@"cc" password:@"345"],
        [[JCUser alloc] initWithName:@"dd" password:@"456"]];
        [array makeObjectsPerformSelector:@selector(say:) withObject:@"早上好"];//将字符串作为参数传入say方法
        [array enumerateObjectsAtIndexes:[NSIndexSet indexSetWithIndexesInRange:NSMakeRange(0, 2)] options:NSEnumerationReverse usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
            NSLog(@"第%ld个元素",idx);
        }];
    }
    return 0;
}

隐式遍历

如果希望对集合中的所有元素进行隐式遍历，并使用集合元素来执行某段代码，则可通过 NS Array 的如下方法来完成。
**enumerateObjectsUsingBlock:**遍历集合中的所有元素，并依次使用元素来执行指定的代码块。

**enumerateObjectsWith Options:usingBlock:**遍历集合中的所有元素，并依次使用元素来执行指定的代码块。该方法可以额外传入一个参数，用于控制遍历的选项，如反向遍历。

**enumerateObjectsAtlndexes:options:usingBlock:**遍历集合中指定范围内的元素，并依次使用元素来执行指定的代码块。该方法可传入一个选项参数，用于控制遍历的选项，如反向遍历。

在直接调用元素方法之中，我们就示范了一个关于enumerateObjectsAtlndexes:options:usingBlock:的用法。[NSIndexSet indexSetWithIndexesInRange:NSMakeRange(0, 2)] 就是设定访问的范围，NSEnumerationReverse实现倒序输出。

NSArray的排序

**sortedArrayUsingFunction:context:**该方法使用排序函数对集合元素进行排序，该排序函数必须返回 NSOrderedDescending 、NSOrderedAscending 、NSOrderedSame这些枚举值，用于代表集合元素的大小。该方法返回一个排序好的新NSArray对象。

**sortedArrayUsingSelector:**该方法使用集合元素自身的方法对集合元素进行排序，集合元素的该方法必须返回NSOrderedDescending 、NSOrderedAscending 、NSOrderedSame 这些枚举值，用于代表集合元素的大小。该方法返回一个排序好的新NSArray对象。

**sortedArrayUsingComparator:**该方法使用代码块对集合元素进行排序，该代码块必须返回NSOrderedDescending、NSOrderedAscending、NSOrderedSame这些枚举值，用于代表集合元素的大小。该方法返回一个排序好的新NSArray 对象。

#import <Foundation/Foundation.h>

NSComparisonResult mySort(id num1, id num2, void* context) {
    int val1 = [num1 intValue];
    int val2 = [num2 intValue];
    if (val1 > val2) {
        return NSOrderedDescending;
    } else if (val1 < val2) {
        return NSOrderedAscending;
    } else {
        return NSOrderedSame;
    }
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //使用方法排序
        NSArray* arr = @[@"acda", @"abbc", @"accd" , @"aadb"];
        arr = [arr sortedArrayUsingSelector:@selector(compare:)];
        NSLog(@"%@", arr);
        //使用函数进行排序
        NSArray *arr1 = @[
            [NSNumber numberWithInt:12],
            [NSNumber numberWithInt:2],
            [NSNumber numberWithInt:-3],
            [NSNumber numberWithInt:0]
        ];
        NSArray *arr2 = [arr1 sortedArrayUsingFunction : mySort context:nil];
        NSLog(@"%@",arr2);
        //使用块语法进行排序
        NSArray *arr3 = [arr1 sortedArrayUsingComparator:^(id n1, id n2) {
            if([n1 intValue] > [n2 intValue]) {
                return NSOrderedAscending;
            } else if ([n1 intValue] < [n2 intValue]){
                return NSOrderedDescending;
            } else {
                return NSOrderedSame;
            }
        }];
        NSLog(@"%@", arr3);
    }
    return 0;
}

以上就是用三种方法进行排序，得到结果如下

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

枚举器遍历集合元素

对于NSArray 对象，除了可根据集合元素的索引来遍历集合元素之外，还可以调用 NSArray对象的如下两个方法来返回枚举器。

**objectEnumerator:**返回NSArray集合的顺序枚举器。
**reverseObjectEnumerator:**返回NSArray集合的逆序枚举器。

上面两个方法都返回一个NSEnumerator枚举器，该枚举器只包含如下两个方法。

**all objects:**获取被枚举集合中的所有元素。
**nextObject:**获取被枚举集合中的下一个元素。

下面是使用NSEnumerator的方法

#import <Foundation/Foundation.h>

NSComparisonResult mySort(id num1, id num2, void* context) {
    int val1 = [num1 intValue];
    int val2 = [num2 intValue];
    if (val1 > val2) {
        return NSOrderedDescending;
    } else if (val1 < val2) {
        return NSOrderedAscending;
    } else {
        return NSOrderedSame;
    }
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //使用allobject进行枚举
        NSArray* arr = @[@"acda", @"abbc", @"accd" , @"aadb"];
        NSEnumerator *en1 = [arr objectEnumerator];
        NSEnumerator *en2 = [arr reverseObjectEnumerator];
        NSLog(@"%@", [en1 allObjects]);
        NSLog(@"%@", [en2 allObjects]);
        //循环遍历实现枚举
        NSArray *arr1 = @[
            [NSNumber numberWithInt:12],
            [NSNumber numberWithInt:2],
            [NSNumber numberWithInt:-3],
            [NSNumber numberWithInt:0]
        ];
        NSEnumerator *en3 = [arr1 objectEnumerator];
        NSEnumerator *en4 = [arr1 reverseObjectEnumerator];
        //快速枚举
        for (id obj in en3) {
            NSLog(@"%@", obj);
        }
        id obj;
        while(obj = [en4 nextObject]) {
            NSLog(@"%@", obj);
        }
    }
    return 0;
}

快速枚举

快速枚举（Fast Enumeration）是Objective-C的一种语法特性，用于方便地遍历集合对象的元素。它提供了一种简洁的方式来遍历数组（NSArray、NSMutableArray）、集合（NSSet、NSMutableSet）以及字典（NSDictionary、NSMutableDictionary）等集合类型。

使用快速枚举语法，你可以以更简洁的方式遍历集合对象的元素，而无需手动迭代或使用索引变量。以下是快速枚举的语法：

for (ObjectType object in collection) {
    // 每次迭代中的操作
}

其中，ObjectType表示集合对象中元素的类型，collection表示要遍历的集合对象，object是在每次迭代中绑定到集合对象中的当前元素。

在上述枚举器的示例中，我们创建了一个数组array。然后，使用for...in循环遍历数组中的每个元素，并将每个元素赋值给obj变量。在每次迭代中，我们打印obj变量的值。

快速枚举语法简化了遍历集合对象的过程，使代码更易读、简洁。它是Objective-C中常用的一种遍历集合对象的方法。

但如果我们要对array在遍历之中进行操作的话，就不能使用快速遍历了。

mutableArray

NSMutableArray 代表集合元素可变的集合，而NSMutableArray底层采用传统数组来容纳集合元素，因此，创建NSMutableArray 时可通过参数指定底层数组的初始容量。NSMutableArray主要新増了如下方法。

添加集合元素的方法:这类方法以add开头。
删除集合元素的方法:这类方法以remove 开头。
替换集合元素的方法:这类方法以replace 开头。
对集合本身排序的方法:这类方法以sort开头。

提示：NSMutableAray同样提供了sortUsingSelector:、sortUsingComparator:、sortUsingFunction: context :这三个方法，这三个方法与前面介绍的NSArray提供的三个排序方法的用法基本相似，区别是NSArray的排序方法是返回一个新的、排序好的NSArray对象，而NSMutableAray的排序方法则对集合本身排序

当涉及到可变数组（NSMutableArray）时，下面是一些适用于该类的示例：

添加集合元素的方法（以add开头）：

NSMutableArray *mutableArray = [NSMutableArray arrayWithObjects:@"Apple", @"Banana", @"Cherry", nil];

[mutableArray addObject:@"Durian"];//直接追加在最后
NSLog(@"%@", mutableArray); // 输出 ["Apple", "Banana", "Cherry", "Durian"]

NSArray *newObjects = @[@"Elderberry", @"Fig"];//直接追加数组
[mutableArray addObjectsFromArray:newObjects];
NSLog(@"%@", mutableArray); // 输出 ["Apple", "Banana", "Cherry", "Durian", "Elderberry", "Fig"]

[mutableArray insertObject:@"Durian" atIndex:1];//插入制定位置
NSLog(@"%@", mutableArray); // 输出 ["Apple", "Durian", "Banana", "Cherry", "Durian", "Elderberry", "Fig"]

NSIndexSet *indexes = [NSIndexSet indexSetWithIndexesInRange:NSMakeRange(1, newObjects.count)];
[mutableArray insertObjects:newObjects atIndexes:indexes];
NSLog(@"%@", mutableArray);

删除集合元素的方法（以remove开头）：

NSMutableArray *mutableArray = [NSMutableArray arrayWithObjects:@"Apple", @"Banana", @"Cherry", @"Durian", @"Elderberry", @"Fig",nil];

[mutableArray removeObject:@"Banana"];
NSLog(@"%@", mutableArray); // 输出 ["Apple", "Cherry", "Durian", "Elderberry", "Fig"]

[mutableArray removeObjectAtIndex:0];
NSLog(@"%@", mutableArray); // 输出 ["Apple", "Cherry", "Durian", "Elderberry", "Fig"]

[mutableArray removeObjectAtRange:NSMakeRange(2, 2)];
NSLog(@"%@", mutableArray); // 输出 ["Apple", "Cherry" , "Fig"]

[mutableArray removeAllObjects];
NSLog(@"%@", mutableArray); // 输出 []

替换集合元素的方法（以replace开头）：

NSMutableArray *mutableArray = [NSMutableArray arrayWithObjects:@"Apple", @"Banana", @"Cherry", nil];

[mutableArray replaceObjectAtIndex:1 withObject:@"Blueberry"];
NSLog(@"%@", mutableArray); // 输出 ["Apple", "Blueberry", "Cherry"]

对集合本身排序的方法（以sort开头）：

NSMutableArray *mutableArray = [NSMutableArray arrayWithObjects:@"Apple", @"Banana", @"Cherry", nil];

[mutableArray sortUsingComparator:^NSComparisonResult(id obj1, id obj2) {
    return [obj1 compare:obj2];
}];
NSLog(@"%@", mutableArray); // 输出 ["Apple", "Banana", "Cherry"]

这些示例演示了在可变数组（NSMutableArray）中使用相关方法的用法。我们可以根据具体需求和集合内容，调用相应的方法来添加、删除、替换和排序数组中的元素。可变数组的特性可让你更灵活地进行操作，添加、删除和替换元素以满足特定的需求。

NSSet

NSSet的相关方法

setByAddingObject:：向集合中添加一个新元素，返回添加元素后的新集合。
setByAddingObjectsFromSet:：使用NSSet 集合向集合中添加多个新元素，返回添加元素后的新集合。
setByAddingObjectsFromArray:：使用 N S A r r a y 集合向集合中添加多个新元素，返回添加元素后的新集合。

allobjects:：返回该集合中所有元素组成的NSArray。
anyObject:：返回该集合中的某个元素。该方法返回的元素是不确定的，但该方法并不保证随机返回集合元素。

containsObject:：判断集合是否包含指定元素。

member:：判断该集合是否包含与该参数相等的元素，如果包含，则返回相等的元素; 否则返回nil。

objectsPassingTest:：需要传入一个代码块对集合元素进行过滤，满足该代码块条件的集合元素被保留下来并组成一个新的NSSet 集合作为返回值。

#import <Foundation/Foundation.h>

NSString* NScollectString (id cellection) {
    NSMutableString *result = [NSMutableString stringWithString:@"["];
    for (id obj in cellection) {
        [result appendString:obj];
        [result appendString:@", "];
    }
    NSInteger len = [result length];
    [result deleteCharactersInRange:NSMakeRange(len - 2, 2)];
    [result appendString:@"]"];
    return result;
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSSet* set1 = [NSSet setWithObjects:@"aa", @"bb", @"cc", @"dd", nil];
        NSLog(@"%ld", [set1 count]);
        NSLog(@"%@",NScollectString(set1));
        for(int i = 0; i < 2; i++) {
            NSLog(@"%@", [set1 anyObject]);//只会返回相同值
        }
        NSSet *set3 = [set1 setByAddingObject:@"ff"];
        NSLog(@"%@",NScollectString(set3));
        NSSet* set2 = [NSSet setWithObjects:@"apple", @"banana", @"cat", @"dog", nil];
        NSSet *set4 = [set1 setByAddingObjectsFromSet: set2];
        //判断交集
     		BOOL b1 = [set1 intersectsSet:set4];
        NSLog(@"set1是否与set4有交集：%d", b1);
        //判断子集
      	BOOL b2 = [set1 isSubsetOfSet:set3];
        NSLog(@"set1是否是set3的子集：%d", b2);
      	//判断是否包含
        BOOL b3 = [set2 containsObject:@"cat"];
        NSLog(@"set2是否包含cat：%d", b3);
      //使用代码块对元素进行过滤
        NSSet *set5 = [set2 objectsPassingTest:^(id obj, BOOL *stop) {
            return (BOOL)([obj length] > 3);
        }];
        NSLog(@"%@",set5);
    }
    return 0;
}

得到的结果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

NSSet判断重复的标准

当向 NSSet 集合中存入一个元素时，NSSet 会调用该对象的 hash 方法来得到该对象的 hashCode 值，然后根据该hashCode 值决定该对象在底层Hash 表中的存储位置，如果根据 hashCode 值计算出来该元素在底层Hash 表中的存储位置已经不相同，那么系统直接将它们保存在不同的位置。
如果两个元素的hashCode 值相同，接下来就要通过 isEqual:方法判断两个元素是否相等，若两个元素通过isEqual:方法比较返回NO，那么NSSet依然认它们不相等，NSSet会把它们都存在底层Hash 表的同一个位置，只是将在这个位置形成链;如果它们通过isEqual:方法

NSOrderedSet

NSOrderedSet 是 Foundation 框架中的一个类，它是一个有序且不可变的集合。NSOrderedSet 继承自NSSet 类，但与NSSet 不同的是，NSOrderedSet 中的元素是按照插入顺序进行排序的。

NSOrderedSet 提供了一种有效的方式来存储和操作一组唯一的对象，同时保持对象的顺序。与 NSArray 和 NSSet 不同，NSOrderedSet 具有以下特点：

有序性：NSOrderedSet 中的元素按照插入的顺序进行排序，因此可以按照元素的索引进行访问和操作。
唯一性：NSOrderedSet 中的元素是唯一的，不会存在重复的元素。
不可变性：NSOrderedSet 是不可变的，一旦创建后，就不能对其进行添加、删除或修改操作。如果需要进行修改操作，可以使用可变子类NSMutableOrderedSet。

访问元素：可以使用 objectAtIndex:、firstObject、lastObject 等方法来访问集合中的元素。
元素计数：可以使用 count 方法获取集合中元素的个数。
集合操作：可以使用 intersectsOrderedSet:、isEqualToOrderedSet:、isSubsetOfOrderedSet: 等方法进行集合之间的交集、相等性和子集判断。
迭代器：可以使用 enumerator 或 block 遍历集合中的元素。
排序：可以使用 sortedArrayUsingComparator:、sortedArrayWithOptions:usingComparator: 等方法对集合中的元素进行排序。

NSString* NScollectString (id cellection) {
    NSMutableString *result = [NSMutableString stringWithString:@"["];
    for (id obj in cellection) {
        [result appendString:obj];
        [result appendString:@", "];
    }
    NSInteger len = [result length];
    [result deleteCharactersInRange:NSMakeRange(len - 2, 2)];
    [result appendString:@"]"];
    return result;
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSSet* set1 = [NSSet setWithObjects:@"aa", @"bb", @"cc", @"dd", nil];
        NSOrderedSet *set = [NSOrderedSet orderedSetWithSet:set1];
        NSLog(@"%@", NScollectString(set));
        NSLog(@"%@", [set firstObject]);
        NSLog(@"%@", [set lastObject]);
        NSLog(@"%@", [set objectAtIndex:2]);
    }
    return 0;
}

NSDictionary

NSDictionary 是 Objective-C 中的一个常用数据结构，用于存储键值对（key-value pairs）的集合。它是不可变的（immutable）且无序的，即一旦创建，就不能修改其中的内容和顺序。

下面是一些关于 NSDictionary 的重要特点和使用方法：

键值对：NSDictionary 由键（key）和相应的值（value）组成。键必须是对象类型，通常为 NSString，而值可以是任何对象类型，甚至可以是 nil。每个键在 NSDictionary 中必须是唯一的，但值可以重复。
不可变性：一旦创建 NSDictionary，就不能修改其内容。如果需要进行修改操作，可以使用可变版本的数据结构 NSMutableDictionary。
无序性：NSDictionary 中的键值对是无序的，即没有固定的顺序。如果需要按照特定顺序访问键值对，可以使用 NSArray 来存储键的顺序，并通过键来访问对应的值。
快速查找：NSDictionary 使用散列表（hash table）实现，对于大多数情况下的查找操作具有很高的效率。通过给定键，可以快速检索对应的值。
创建 NSDictionary 对象的方法：
- 使用字面量语法创建：@{key1: value1, key2: value2, ...}
- 使用类方法创建：+[NSDictionary dictionaryWithObjectsAndKeys:] 或 +[NSDictionary dictionaryWithObjects:forKeys:]
- 使用初始化方法创建：-initWithObjectsAndKeys: 或 -initWithObjects:forKeys:
访问数据：
- 通过键获取值：-objectForKey: 或 [] 语法。
- 获取所有键或值的集合：-allKeys 和 -allValues 方法。
- 遍历字典：可以使用快速枚举语法 for-in，或者使用 -enumerateKeysAndObjectsUsingBlock: 方法传入一个 block 进行遍历操作。
判断是否包含某个键或值：可以使用 -containsKey: 和 -containsObject: 方法来判断是否存在指定的键或值。

需要注意的是，NSDictionary 是不可变的，一旦创建就不能修改其内容。如果需要在运行时进行增加、删除或修改操作，可以使用可变版本的 NSMutableDictionary。

NSMutableDictionary

当涉及到 NSDictionary 的可变版本时，我们可以使用 NSMutableDictionary 来进行增加、删除和修改操作。NSMutableDictionary 继承自 NSDictionary，因此它具有 NSDictionary 的所有特性，并添加了一些额外的方法来修改其内容。

下面是一些常用的 NSMutableDictionary 方法：

添加和修改操作：
- -setObject:forKey:：将指定的值与键关联，如果键已存在，则替换对应的值。
- -setObject:forKeyedSubscript:：通过下标语法为指定键设置值，与 -setObject:forKey: 等效。
- -addEntriesFromDictionary:：将另一个字典中的键值对添加到当前字典中。
删除操作：
- -removeObjectForKey:：移除指定键的键值对。
- -removeAllObjects：移除所有的键值对。
替换操作：
- -replaceObjectForKey:withObject:：用指定的值替换指定键的当前值。
- -setDictionary:：用另一个字典中的键值对替换当前字典的内容。
键值对的获取和遍历：
- -objectForKey:：通过给定的键获取对应的值。
- -allKeys 和 -allValues：获取所有键或所有值的集合。
- -enumerateKeysAndObjectsUsingBlock:：通过 block 遍历字典的键值对。
判断是否包含某个键或值：
- -containsKey: 和 -containsObject:：判断字典中是否包含指定的键或值。