概念
- 浅拷贝：只copy一份对象的指针，指向对象的内存地址，引用计数+1。
- 深拷贝：内容拷贝 分配了新的内存 不会影响旧对象的引用计数。
条件
iOS中并不是所有对象都支持
Copy和MutableCopy，遵守NSCopying协议的类可以发送Copy消息，遵循MutableCopying协议的类可以发送MutableCopy消息。若未曾遵守该协议却发送相应消息会发生异常。遵守NSCopying协议必须实现
copyWithZone方法,遵守NSMutableCopying协议必须实现mutableCopyWithzone方法。
实例分析
非容器对象 字符串
非容器对象包括NSString, NSNumber等，此处以字符串为例进行分析
- 对
NSString做copy和mutableCopy操作
NSString *originString = @"abcdefghijk";
NSString *ori_copy = [originString copy];
NSMutableString *ori_muCopy = [originString mutableCopy];
NSLog(@"originString : %p, %p %@ %@",originString, &originString,[originString class],originString);
NSLog(@"ori_copy : %p, %p %@ %@",ori_copy, &ori_copy,[ori_copy class],ori_copy);
NSLog(@"ori_muCopy : %p, %p %@ %@",ori_muCopy, &ori_muCopy,[ori_muCopy class],ori_muCopy);
[ori_muCopy appendString:@"12"];
NSLog(@"ori_muCopy : %p, %p %@ %@",ori_muCopy, &ori_muCopy,[ori_muCopy class],ori_muCopy);
//originString : 0x1062c2090, 0x7ffee9941408 __NSCFConstantString abcdefghijk
//ori_copy : 0x1062c2090, 0x7ffee9941400 __NSCFConstantString abcdefghijk
//ori_muCopy : 0x600001c10ab0, 0x7ffee99413f8 __NSCFString abcdefghijk
//ori_muCopy : 0x600001c10ab0, 0x7ffee99413f8 __NSCFString abcdefghijk12
对字符串常量进行
copy操作，是创建一个新的指针指向原指针指向的地址。
对字符串常量进行mutableCopy，将对象里的内容复制到一块新的内存，并把新的对象指针指向新的内存地址，新的对象是可变字符串。
- 对
NSMutableString做copy和mutableCopy操作
//对可变字符串进行copy、mutableCopy
NSMutableString *ori_muCopy_copy = [ori_muCopy copy];
NSMutableString *ori_muCopy_muCopy = [ori_muCopy mutableCopy];
NSLog(@"ori_muCopy_copy : %p, %p %@ %@",ori_muCopy_copy, &ori_muCopy_copy,[ori_muCopy_copy class],ori_muCopy_copy);
NSLog(@"ori_muCopy_muCopy : %p, %p %@ %@",ori_muCopy_muCopy, &ori_muCopy_muCopy,[ori_muCopy_muCopy class],ori_muCopy_muCopy);
// [ori_muCopy_copy appendString:@"12"];//崩溃 不可变字符串
[ori_muCopy_muCopy appendString:@"12"];
NSLog(@"ori_muCopy_muCopy : %p, %p %@ %@",ori_muCopy_muCopy, &ori_muCopy_muCopy,[ori_muCopy_muCopy class],ori_muCopy_muCopy);
//ori_muCopy_copy : 0x60000122d480, 0x7ffee99413f0 __NSCFString abcdefghijk12
//ori_muCopy_muCopy : 0x600001c7cbd0, 0x7ffee99413e8 __NSCFString abcdefghijk12
//ori_muCopy_muCopy : 0x600001c7cbd0, 0x7ffee99413e8 __NSCFString abcdefghijk1212
总结
非容器对象:
| 原对象是否可变 | copy类型 | 深浅拷贝 | 返回对象是否可变 |
|---|---|---|---|
| 不可变对象 | copy | 浅拷贝 | 不可变 |
| 不可变对象 | mutableCopy | 深拷贝 | 可变 |
| 可变对象 | copy | 深拷贝 | 不可变 |
| 可变对象 | mutableCopy | 深拷贝 | 可变 |
不管原对象是否可变进行
mutableCopy后得到的对象都是可变的；
只有不可变对象的copy操作才是浅拷贝，其它都是深拷贝;
容器对象：数组
容器对象包括NSArray、NSDictionary、NSSet等，此处以数组为例进行分析
- 不可变数组进行
copy、mutableCopy操作
NSMutableString *mStr = [[NSMutableString alloc] initWithString:@"123456"];
//不可变数组 copy、mutableCopy操作
NSArray *arr = @[mStr,mStr];
NSMutableArray *arr_copy = [arr copy];
NSMutableArray *arr_muCopy = [arr mutableCopy];
NSLog(@"arr : %p, %p, %@",arr, &arr,[arr class]);
NSLog(@"arr_copy : %p, %p, %@",arr_copy, &arr_copy,[arr_copy class]);
NSLog(@"arr_muCopy : %p, %p, %@",arr_muCopy, &arr_muCopy,[arr_muCopy class]);
//arr : 0x600002e02540, 0x7ffeed61b3e8, __NSArrayI
//arr_copy : 0x600002e02540, 0x7ffeed61b3e0, __NSArrayI
//arr_muCopy : 0x600002009350, 0x7ffeed61b3d8, __NSArrayM
- 可变数组进行
copy、mutableCopy操作
NSMutableArray *arr_muCopy_copy = [arr_muCopy copy];
NSMutableArray *arr_muCopy_muCopy = [arr_muCopy mutableCopy];
NSLog(@"arr_muCopy_copy : %p, %p, %@",arr_muCopy_copy, &arr_muCopy_copy,[arr_muCopy_copy class]);
NSLog(@"arr_muCopy_muCopy : %p, %p, %@",arr_muCopy_muCopy, &arr_muCopy_muCopy,[arr_muCopy_muCopy class]);
//arr_muCopy_copy : 0x600002e02580, 0x7ffeed61b3d0, __NSArrayI
//arr_muCopy_muCopy : 0x600002009320, 0x7ffeed61b3c8, __NSArrayM
容器对象:
| 原对象是否可变 | copy类型 | 深浅拷贝 | 返回对象是否可变 |
|---|---|---|---|
| 不可变对象 | copy | 浅拷贝 | 不可变 |
| 不可变对象 | mutableCopy | 深拷贝 | 可变 |
| 可变对象 | copy | 深拷贝 | 不可变 |
| 可变对象 | mutableCopy | 深拷贝 | 可变 |
容器对象和非容器对象拷贝完全一致，
那么就完了吗？并没有
将arr数组里的元素修改，然后再看下输出情况
NSMutableString *temp = arr[0];
[temp appendString:@"789"];
NSLog(@"arr : %@",arr);
NSLog(@"arr_copy : %@",arr_copy);
NSLog(@"arr_muCopy : %@",arr_muCopy);
NSLog(@"arr_muCopy_copy : %@",arr_muCopy_copy);
NSLog(@"arr_muCopy_muCopy : %@",arr_muCopy_muCopy);
//arr : (123456789, 123456789)
//arr_copy : (123456789, 123456789)
//arr_muCopy : (123456789, 123456789)
//arr_muCopy_copy : (123456789, 123456789)
//arr_muCopy_muCopy : (123456789, 123456789)
只改变一个数组元素，其它数组元素都跟着变化
这里需要引入一个新的概念
单层深拷贝与完全深拷贝
深拷贝，就是把原有对象的内容直接克隆一份到新对象，但是对于容器对象而言，这里有一个坑就是他只会复制一层对象，而不会复制第二层甚至更深层次的对象
把
NSMutableArray *arr_copy = [arr copy];
NSMutableArray *arr_muCopy = [arr mutableCopy];
替换成
NSMutableArray *arr_copy = [[NSMutableArray alloc]initWithArray:arr copyItems:YES];//[arr copy];
NSMutableArray *arr_muCopy = [[NSMutableArray alloc]initWithArray:arr copyItems:YES];//[arr mutableCopy];
输出
NSLog(@"arr : %@",arr);
NSLog(@"arr_copy : %@",arr_copy);
NSLog(@"arr_muCopy : %@",arr_muCopy);
NSLog(@"arr_muCopy_copy : %@",arr_muCopy_copy);
NSLog(@"arr_muCopy_muCopy : %@",arr_muCopy_muCopy);
//arr : (123456789, 123456789)
//arr_copy : (123456, 123456)
//arr_muCopy : (123456, 123456)
//arr_muCopy_copy : (123456, 123456)
//arr_muCopy_muCopy : (123456, 123456)
这样问题就都解决了吗？ 并没有
看下数组嵌套数组的情况
NSMutableArray * dataArray1=[NSMutableArray arrayWithObjects:
[NSMutableString stringWithString:@"123456"],nil];
NSMutableArray * dataArray2 = [NSMutableArray arrayWithObjects: dataArray1,nil];
NSMutableArray * dataArray3 = [[NSMutableArray alloc]initWithArray:dataArray2 copyItems:YES];
NSMutableString * subStr1;
subStr1 = dataArray1[0];
[subStr1 appendString:@"789"];
//NSLog(@"%p %p %p %p",dataArray1,&dataArray1,subStr1,&subStr1);
NSMutableString * subStr2;
NSMutableArray * subArr2 = dataArray2[0];
subStr2 = subArr2[0];
NSLog(@"%p %p %p %p %p %p",dataArray2,&dataArray2,subArr2,&subArr2,subStr2,&subStr2);
NSMutableArray * subArr3 = dataArray3[0];
NSMutableString *subStr3;
subStr3 = subArr3[0];
NSLog(@"%p %p %p %p %p %p",dataArray3,&dataArray3,subArr3,&subArr3,subStr3,&subStr3);
//0x600003a31740 0x7ffee7ce5400 0x600003a31770 0x7ffee7ce53e0 0x600003a31800 0x7ffee7ce53e8
//0x600003a31710 0x7ffee7ce53f8 0x60000360c0a0 0x7ffee7ce53d8 0x600003a31800 0x7ffee7ce53d0
从打印结果可以看到：
-
subArr2与subArr3没有任何关系，指针地址和内存地址都没有关系 -
subStr2与subStr3指向同一块内存
问题：为什么subStr2与subStr3指向同一块内存？，怎么解决?
解答：
因为[[NSMutableArray alloc]initWithArray:dataArray2 copyItems:YES];只进行了一层拷贝，对于第二层或者更多层的就无效了；
要想对多层集合对象进行复制，我们需要进行完全复制，这里可以使用归档和反归档。
NSMutableArray * dataArray4 = [NSKeyedUnarchiver unarchiveObjectWithData:[NSKeyedArchiver archivedDataWithRootObject:dataArray2]];
NSMutableArray * subArr4 = dataArray4[0];
NSMutableString *subStr4;
subStr4 = subArr4[0];
NSLog(@"%p %p %p %p %p %p",dataArray4,&dataArray4,subArr4,&subArr4,subStr4,&subStr4);
//0x600003a31530 0x7ffee7ce53c8 0x600003a31020 0x7ffee7ce53c0 0x600003a314d0 0x7ffee7ce53b8
此时dataArray4及其元素与dataArray2没有任何关系，是完全拷贝了一份。
copy做修饰符
非容器对象 字符串
- 不可变字符串对其赋值
@property (nonatomic, copy) NSString *coStr;
NSString *str = @"liu";
NSLog(@"==%p",str);
self.coStr = str;
self.coStr = @"bh";
NSLog(@"==%p %@ %@",self.coStr,self.coStr,str);
//==0x102cc06d0
//==0x102cc0710 bh liu
使用不可变字符串给用copy修饰的字符串赋值时，会开辟一块新的内存。
- 可变字符串对其赋值
NSMutableString *mStr = [[NSMutableString alloc] initWithString:@"abc"];
NSLog(@"==%p",mStr);
self.coStr = mStr;
self.coStr = @"de";
mStr = @"fg".mutableCopy;
NSLog(@"==%p %@ %@",self.coStr,self.coStr,mStr);
//==0x28010ced0
//==0x100fb0710 de fg
使用可变字符串给用copy修饰的字符串赋值时，会开辟一块新的内存。
总结
对非容器对象而言，使用
copy修饰相当于深拷贝
容器对象 数组
-
copy修饰不可变数组，用不可变数组对这个数组赋值
@property (nonatomic, copy) NSArray *coArray;
@property (nonatomic, strong) NSArray *stArray;
NSMutableString *mStr = [[NSMutableString alloc] initWithString:@"abc"];
NSArray *array = [NSArray arrayWithObject:mStr];
self.coArray = array;
self.stArray = array;
[mStr appendString:@"123"];
NSLog(@"==%p %@ %p",array,array,mStr);
NSString *cotemp = self.coArray[0];
NSLog(@"==%p %@ %p",self.coArray,self.coArray,cotemp);
NSString *sttemp = self.stArray[0];
NSLog(@"==%p %@ %p",self.stArray,self.stArray,sttemp);
//==0x600002586f90 (abc123) 0x600002978c90
//==0x600002586f90 (abc123) 0x600002978c90
//==0x600002586f90 (abc123) 0x600002978c90
将不可变数组赋值给copy修饰的数组时，数组地址和数组成员变量地址都没有改变，相当于浅拷贝
-
copy修饰不可变数组，用可变数组对这个数组赋值
@property (nonatomic, copy) NSArray *coArray;
@property (nonatomic, strong) NSArray *stArray;
NSMutableString *mStr = [[NSMutableString alloc] initWithString:@"abc"];
NSMutableArray *mArray = [NSMutableArray arrayWithObjects:mStr, nil];
self.coArray = mArray;
self.stArray = mArray;
[mStr appendString:@"123"];
NSLog(@"==%p %@ %p",mArray,mArray,mStr);
NSString *cotemp = self.coArray[0];
NSLog(@"==%p %@ %p",self.coArray,self.coArray,cotemp);
NSString *sttemp = self.stArray[0];
NSLog(@"==%p %@ %p",self.stArray,self.stArray,sttemp);
//==0x600000948600 (abc123) 0x6000009485a0
//==0x6000005b1bd0 (abc123) 0x6000009485a0
//==0x600000948600 (abc123) 0x6000009485a0
将可变数组赋值给copy修饰的数组时，数组的地址发生改变，但数组元素仍指向原来的内存地址， 相当于单层深拷贝
- copy修饰可变数组，用不可变数组对这个数组赋值
@property (nonatomic, copy) NSMutableArray *coArray;
@property (nonatomic, strong) NSArray *stArray;
NSMutableString *mStr = [[NSMutableString alloc] initWithString:@"abc"];
NSArray *array = @[mStr];
self.coArray = [NSMutableArray arrayWithArray:array];
self.stArray = array;
[mStr appendString:@"123"];
NSLog(@"==%p %@ %p",array,array,mStr);
NSMutableArray *cotemp = self.coArray[0];
NSLog(@"==%p %@ %p",self.coArray,self.coArray,cotemp);
NSMutableArray *sttemp = self.stArray[0];
NSLog(@"==%p %@ %p",self.stArray,self.stArray,sttemp);
//==0x600003d293c0 (abc123) 0x6000031c8090
//==0x600003d293e0 (abc123) 0x6000031c8090
//==0x600003d293c0 (abc123) 0x6000031c8090
将不可变数组赋值给copy修饰的可变数组，数组的地址发生改变但是数组元素仍指向原来的地址，相当于单层深拷贝
[self.coArray addObject:@"2"];
如果想给数组添加元素是不行的，会崩溃，所以应该避免用copy修饰可变数组
- copy修饰可变数组，用可变数组对这个数组赋值
@property (nonatomic, copy) NSArray *coArray;
@property (nonatomic, strong) NSArray *stArray;
NSMutableString *mStr = [[NSMutableString alloc] initWithString:@"abc"];
NSMutableArray *array = @[mStr].mutableCopy;
self.coArray = array;
self.stArray = array;
[mStr appendString:@"123"];
NSLog(@"==%p %@ %p",array,array,mStr);
NSMutableArray *cotemp = self.coArray[0];
NSLog(@"==%p %@ %p",self.coArray,self.coArray,cotemp);
NSMutableArray *sttemp = self.stArray[0];
NSLog(@"==%p %@ %p",self.stArray,self.stArray,sttemp);
//==0x6000029e5cb0 (abc123) 0x6000029e4090
//==0x60000254bea0 (abc123) 0x6000029e4090
//==0x6000029e5cb0 (abc123) 0x6000029e4090
将可变数组赋值给copy修饰的可变数组，数组的地址发生改变但是数组元素仍指向原来的地址，相当于单层深拷贝
[self.coArray addObject:@"2"];
同样也是不能给数组添加元素的，会崩溃，所以应该避免用copy修饰可变数组
总结
| copy修饰的数组类型 | 赋值数据类型 | 拷贝类型 | 是否能直接操作数据（添加、删除） |
|---|---|---|---|
| NSArray | NSArray | 浅拷贝 | 不能 |
| NSArray | NSMutableArray | 单层深拷贝 | 不能 |
| NSMutableArray | NSArray | 单层深拷贝 | 不能 |
| NSMutableArray | NSMutableArray | 单层深拷贝 | 不能 |