iOS-copy与mutableCopy浅析
在iOS开发中，当提到深拷贝和浅拷贝的时候，大家都说懂，简单；都会说，浅拷贝：指针（地址）拷贝，不会产生新对象；深拷贝：内容拷贝，会产生新对象，但当问及大家copy与mutableCopy的时候，他们各自是深拷贝还是浅拷贝的时候，谁又有底气答对呢？下面一起研究下吧
1、不可变字符串的拷贝
NSString *string = @"string";
NSString *str1 = [string copy]; // 没有产生新对象 【浅拷贝】
NSMutableString *str2 = [string mutableCopy]; // 产生新对象 【深拷贝】
NSLog(@"%p %p %p", string, [string copy], [string mutableCopy]);
打印结果如下：
根据打印结果解析：
当不可变字符串调用copy的时候，指针地址没有发生改变，也就意味着没有产生新的对象，所以属于浅拷贝；
当不可变字符串调用mutableCopy的时候，指针地址发生了改变，意味着产生新的对象，所以属于深拷贝。
2、可变字符串的拷贝
NSMutableString *string = [NSMutableString string];
[string appendString:@"text1"];
NSString *str1 = [string copy]; // 产生新对象,变为不可变字符串【深拷贝】
NSMutableString *str2 = [string mutableCopy];// 产生新对象,还是可变字符串 【深拷贝】
[str2 appendString:@"text2"];
NSLog(@"%p %p %p", string, [string copy], [string mutableCopy]);
NSLog(@"%@ %@ %@", string, str1, str2);
打印结果如下：
根据打印结果解析：
当可变字符串调用copy的时候，指针地址发生了改变，也就意味着产生新的对象，所以属于深拷贝；
当可变字符串调用mutableCopy的时候，指针地址发生了改变，意味着产生新的对象，所以属于深拷贝。
3、不可变数组的拷贝
NSArray *array = @[@"text1", @"text2"];
NSArray *array1 = [array copy]; // 没有产生新对象 【浅拷贝】
NSMutableArray *array2 = [array mutableCopy]; // 产生新对象,变为可变数组【深拷贝】
[array2 addObject:@"text3"];
NSLog(@"%p %p %p", array, array1, array2);
NSLog(@"%@ %@ %@", array, array1, array2);
打印结果如下：
根据打印结果解析：
当不可变数组调用copy的时候，指针地址没有发生改变，意味着没有产生新的对象，所以属于浅拷贝；
当不可变数组调用mutableCopy的时候，指针地址发生了改变，意味着产生新的对象，所以属于深拷贝。
4、可变数组的拷贝
NSMutableArray *mutableArray = @[@"text1", @"text2"].mutableCopy;
NSArray *array1 = [mutableArray copy]; // 产生新对象,变为不可变数组【深拷贝】
NSMutableArray *mutableArray1 = [mutableArray mutableCopy]; // 产生新对象,变为可变数组 【深拷贝】
[mutableArray1 addObject:@"text3"];
NSLog(@"%p %p %p", mutableArray, [mutableArray copy], [mutableArray mutableCopy]);
NSLog(@"%@ %@ %@", mutableArray, array1, mutableArray1);
打印结果如下：
根据打印结果解析：
当可变数组调用copy的时候，指针地址发生了改变，也就意味着产生新的对象，所以属于深拷贝；
当可变数组调用mutableCopy的时候，指针地址发生了改变，意味着产生新的对象，所以属于深拷贝。
5、自定义对象的拷贝
由于自定义对象不考虑可变，所以忽略mutableCopy
首先，当对象需要调用 copy 的时候，需要遵守遵守 NSCopying 协议 和 调用 copyWithZone：这个方法
@interface Dog : NSObject
/** 姓名 */
@property (nonatomic, copy) NSString *name;
/** 年龄 */
@property (nonatomic, assign) int age;
@end
// 需要遵守 NSCopying 协议
@interface Dog ()
@end
@implementation Dog
// 当对象需要调用 copy 的时候，需要调用 copyWithZone：这个方法
- (id)copyWithZone:(NSZone *)zone
{
Dog *dog = [[Dog allocWithZone:zone] init];
dog.name = self.name;
dog.age = self.age;
return dog;
}
@end
Dog *dog = [[Dog alloc] init]; // [object copyWithZone:zone]
dog.name = @"huahua";
dog.age = 1;
Dog *newDog = [dog copy]; // 产生新对象【深拷贝】
NSLog(@"%@ %@",dog,newDog);
NSLog(@"%@ %@",dog.name,newDog.name);
打印结果如下：
根据打印结果解析：
当自定义对象调用copy的时候，指针地址发生了改变，也就意味着产生新的对象，所以属于深拷贝；
6、属性中的copy 和 strong
在平时定义属性的时候，对于NSString 和 block 我们经常用 copy 来修饰
数组和字典等类型用 strong 来修饰；
当使用 copy 修饰属性的时候，属性的setter方法会调用[object copy]产生新的对象，
这样，当原object对象的值发生改变时，并不影响新对象值；
// 定义NSString
@property(nonatomic, copy) NSString *name;
.
.
.
// 当调用上面的copy的时候，等价于下面的代码
- (void)setName:(NSString *)name {
if (_name != name) {
[_name release];
_name = [name copy];
}
}
当使用 strong 修饰属性的时候，属性的setter方法会直接强引用该对象，
这样，当原object对象的值发生改变时，新对象的属性也改变；
例如：我们平时使用strong修饰的NSMutableArray，这个可变数组在当前文件中只有一个，而且是可变的;
/** 数组 */
@property(nonatomic,strong)NSMutableArray *array;
.
.
.
// 当调用上面的strong的时候，等价于下面的代码
-(void)setArray:(NSMutableArray *)array{
_array = array;
}
以前面的自定义Dog对象进行举例：
// 定义一个可变的字符，作为小狗的name
NSMutableString *dogName = [NSMutableString stringWithString:@"huahua"]; // dogName == "huahua"
Dog *dog = [[Dog alloc] init];
// 将字符赋值给dog的name属性
dog.name = dogName;
// 当小狗的name值发生改变时
[dogName appendString:@"lvlv"]; // dogName == "huahualvlv"
// 小狗的名还是原来的姓名
NSLog(@"%@",dog.name); // 打印结果：huahua
分析：当给dog.name 赋值时，会将 [dogName copy] 后的结果赋值给 dog.name，这样,当dogName字符的值发生改变后，不会影响 dog.name 的值；
总结：当不可变类型对象调用copy拷贝后，不会产生新的对象，属于浅拷贝，其他类型对象不管调用copy亦或是mutableCopy，都会产生新的对象，属于深拷贝！