copy和mutableCopy

示例中要打印引用计数（retainCount），所以关闭了ARC。

示例都写在ViewController中，因此只在这个文件后面设置了-fno-objc-arc

1 NSString & NSMutableString

1.1 不可变字符串（NSString）的copy和mutableCopy

NSString *str = @"123";
NSLog(@"str:%p, str.rCount:%lu", str, (unsigned long)str.retainCount);
NSString *str_strCopy = [str copy];
NSLog(@"str_strCopy:%p, str.rCount:%lu", str_strCopy, (unsigned long)str.retainCount);
NSMutableString *muStr_strCopy = [str copy];
NSLog(@"muStr_strCopy:%p, str.rCount:%lu", muStr_strCopy, (unsigned long)str.retainCount);
NSMutableString *muStr_strMuCopy = [str mutableCopy];
NSLog(@"muStr_strMuCopy:%p, str.rCount:%lu", muStr_strMuCopy, (unsigned long)str.retainCount);

对NSString进行copy，其实就是将指针指向了数据源的地址。而且类型都是常量字符串类型（__NSCFConstantString*）。
mutableCopy，则是在堆区新分配的内存空间，并将指针指向了这块内存区域。类型也变成了可变的字符串类型（__NSCFString*）
注意：打印的retainCount都是数据源str的。目的想了解通过copy或者mutableCopy后，对数据源的引用计数会有什么影响。后续的案例也同理，都是打印数据源的引用计数。
常量字符串（__NSCFConstantString），保存在数据区中，是不会被释放的，所以它的值是18446744073709551615 = (2^64)-1，也就是ULONG_MAX

1.2 可变字符串（NSMutableString）的copy和mutableCopy

NSMutableString *muStr = [[NSMutableString alloc] initWithString:@"123"];
//    NSMutableString *muStr = [[NSMutableString alloc] initWithString:@"可变字符串"];
NSLog(@"muStr:%p, muStr.rCount:%lu", muStr, (unsigned long)muStr.retainCount);
NSString *str_muStrCopy = [muStr copy];
NSLog(@"str_muStrCopy:%p, muStr.rCount:%lu", str_muStrCopy, (unsigned long)muStr.retainCount);
NSMutableString *muStr_muStrCopy = [muStr copy];
NSLog(@"muStr_muStrCopy:%p, muStr.rCount:%lu", muStr_muStrCopy, (unsigned long)muStr.retainCount);
NSMutableString *muStr_muStrMuCopy = [muStr mutableCopy];
NSLog(@"muStr_muStrMuCopy:%p, muStr.rCount:%lu", muStr_muStrMuCopy, (unsigned long)muStr.retainCount);

对于可变字符串，copy和mutableCopy都会重新分配一个内存空间。
NSTaggedPointerString*是苹果在64位操作系统上提出的“小对象”类型。可以将注释代码打开，将第一行代码注释掉，也就是设置一个复杂点的字符串。就看不到“小对象”类型了。
引用计数方面，由于都是新分配的内存空间，对源数据的引用计数没有影响。

2. NSArray & NSMutableArray

2.1 NSArray的copy和mutableCopy

NSArray *arr = @[[NSMutableString stringWithString:@"1"], @"2"];
NSLog(@"arr:%p, arr.rCount:%lu", arr, (unsigned long)arr.retainCount);
NSArray *arr_arrCopy = [arr copy];
NSLog(@"arr_arrCopy:%p, arr.rCount:%lu", arr_arrCopy, (unsigned long)arr.retainCount);
NSMutableArray *muArr_arrCopy = [arr copy];
NSLog(@"muArr_arrCopy:%p, arr.rCount:%lu", muArr_arrCopy, (unsigned long)arr.retainCount);
NSMutableArray *muArr_arrMuCopy = [arr mutableCopy];
NSLog(@"muArr_arrMuCopy:%p, arr.rCount:%lu", muArr_arrMuCopy, (unsigned long)arr.retainCount);
    
NSMutableString *t1 = arr[0];
[t1 appendString:@"50"];//@“1”追加@“50”  变成@“150”
NSString * t2 = arr[1];
t2 = @"change";//修改不成功
NSLog(@"muArr:%@", arr);
NSLog(@"arr_muArrCopy:%@", arr_arrCopy);
NSLog(@"muArr_muArrCopy:%@", muArr_arrCopy);
NSLog(@"muArr_muArrMuCopy:%@", muArr_arrMuCopy);

不可变的数组类型进行copy操作，返回的还是不可变类型（__NSArrayI *）。是不能增加元素、删除元素和修改元素。会影响到数据源的引用计数。
mutableCopy操作则是变成了可变数组类型（__NSArrayM *）。地址不一样，所以不会影响引用计数。
虽然不能修改数组中的元素，但是要知道元素都是指针类型，不能修改的是指针指向的地址，但是可以修改地址中的值。第一个元素是可变字符串，它是在堆区的，所以我们可以进行修改。
第二个元素是常量指针，如果进行修改，那么就相当于指针指向的地址变了，不可变数组中是不允许的，所以设置也没有效果。

2.2 NSMutableArray的copy和mutableCopy

NSMutableArray *muArr = [NSMutableArray arrayWithArray:@[[NSMutableString stringWithString:@"1"], @"2"]];
NSLog(@"muArr:%p, muArr.rCount:%lu", muArr, (unsigned long)muArr.retainCount);
NSArray *arr_muArrCopy = [muArr copy];
NSLog(@"arr_muArrCopy:%p, muArr.rCount:%lu", arr_muArrCopy, (unsigned long)muArr.retainCount);
NSMutableArray *muArr_muArrCopy = [muArr copy];
NSLog(@"muArr_muArrCopy:%p, muArr.rCount:%lu", muArr_muArrCopy, (unsigned long)muArr.retainCount);
NSMutableArray *muArr_muArrMuCopy = [muArr mutableCopy];
NSLog(@"muArr_muArrMuCopy:%p, muArr.rCount:%lu", muArr_muArrMuCopy, (unsigned long)muArr.retainCount);

NSMutableString *mt1 = muArr[0];
[mt1 appendString:@"00"];
muArr[1] = @"haha";
NSLog(@"muArr:%@", muArr);
NSLog(@"arr_muArrCopy:%@", arr_muArrCopy);
NSLog(@"muArr_muArrCopy:%@", muArr_muArrCopy);
NSLog(@"muArr_muArrMuCopy:%@", muArr_muArrMuCopy);

copy操作会将可变数组变化成非可变状态，状态转变，就会重新开辟内存空间。但是不会影响数据源的引用计数
mutableCopy和之前的情况一样。
由于数据源是可变的状态，所以数组中的元素是可以增删改的。

2.3 数组中的元素

数组中的元素都是指针类型，经过copy和mutableCopy之后的数组里的元素的指针地址与源数组的元素地址相同。但是当遇到开辟空间的时候，会影响元素的引用计数。原因是元素又加入到新的数组中，引用计数当然要进行+1处理：

NSArray *arr = @[[NSMutableString stringWithString:@"1"], @"2"];
NSMutableString * str = arr[0];
NSLog(@"str:%p, str.rCount:%lu", str, (unsigned long)str.retainCount);
NSArray *arr_arrCopy = [arr copy];
NSLog(@"str:%p, str.rCount:%lu", str, (unsigned long)str.retainCount);
NSMutableArray *muArr_arrCopy = [arr copy];
NSLog(@"str:%p, str.rCount:%lu", str, (unsigned long)str.retainCount);
NSMutableArray *muArr_arrMuCopy = [arr mutableCopy];
NSLog(@"str:%p, str.rCount:%lu", str, (unsigned long)str.retainCount);

3. 总结

copy和mutableCopy方法含义上来说都是浅拷贝.
在上述的示例中,对容器拷贝,生成一个新的副本容器.而里面的元素不会进行重新生成,而是引用的方式,这和一个对象赋值另一个对象没有什么不同.
如果想要进行深拷贝,可以使用"归档"NSKeyedArchive类,或者写文件的方式.

源对象类型	拷贝方式	目标对象类型	是否影响源对象引用计数
不可变对象	copy	不可变对象	影响
不可变对象	mutableCopy	可变对象	不影响
可变对象	copy	不可变对象	不影响
可变对象	mutableCopy	可变对象	不影响

只有不可变对象进行copy，目标对象还是不可变类型。不会开辟内存空间。其他的都会开辟空间。

4. 面试

面试中经常会问NSString类型的属性用strong修饰还是copy修饰。
答案肯定是用copy

源数据如果是NSSring类型，这两种方式没有区别。因为NSString底层是常量字符串，copy后类型不变化。引用计数是最大值，strong对它也没有影响。
但是源数据如果是NSMutableString类型：
- strong修饰后修改引用计数，属性和源数据指向相同的地址空间，一个修改另一个就跟着修改。
- copy修饰，属性接受到的是不可变类型，也就是NSString，而且开辟了新的内存空间。属性和源数据指向不同地方。这样就不会出现联动的情况了。