iOS中的Copy和mutableCopy

拷贝：顾名思义就是将一个对象复制一份出来。说到iOS中得拷贝操作，大概用的最多的应该就是数组的拷贝操作。如果自己的类想支持拷贝操作，那就要实现NSCopy协议。

- (id)copyWithZone:(NSZone *)zone;

与之对应的还有一个可变版本拷贝操作，需要实现NSMutableCopying协议。

- (id)mutableCopyWithZone:(nullable NSZone *)zone;

自定义这种网上还是比较多，这里主要介绍字符串，数组,字典的Copy和mutableCopy操作，以及衍伸出的浅拷贝和深拷贝的问题。

1. NSString

大家一般申明字符串属性的时候都会用这种方式

@property (nonatomic, copy) NSString *str;

当然也会有这种

@property (nonatomic, strong) NSString *str;

那到底应该使用哪一种比较好，还是说两者都可以使用呢，接下来将进一步来分析他们。
当我们给字符串属性赋值的时候，实际调用的是set方法:

首先我们来分析strong这种方式:

- (void)setStr:(NSString *)str {
    _str = str;
}

�接下来测试一下：

NSString *a = @"One";
self.str = a;
NSLog(@"变量a所指向的地址--%p,内容--%@",a,a);
NSLog(@"self.str所指向的地址--%p,内容--%@",self.str,self.str);

 变量a所指向的地址--0x10a91c088,内容--One
 self.str所指向的地址--0x10a91c088,内容--One

如上述代码可以看到，将变量a赋值给self.str的时候，其实就是让self.str指向了变量a所指向的地址，也就是字符串One在堆中得地址。所以self.str和变量a指向的是同一个地址。

//给a重新赋值
a = @"Two";
NSLog(@"变量a所指向的地址--%p,内容--%@",a,a);
NSLog(@"self.str所指向的地址--%p,内容--%@",self.str,self.str);
变量a所指向的地址--0x10a91c088,内容--Two
self.str所指向的地址--0x10a91c0e8,内容--One

当我们给变量a重新赋值的时候，其实是让变量a重新指向了新的地址，也就是字符串Two在堆中的地址，但是self.str并不会改变。无论变量a怎么赋值，都不会影响到self.str，这也是我们所希望看到的。

//定义一个可变的字符串a
NSMutableString *a = [NSMutableString stringWithString:@"One"];
self.str = a;
NSLog(@"变量b所指向的地址--%p,内容--%@",a,a); 
NSLog(@"self.str所指向的地址--%p",self.str);

//a中追加了字符串123
[a appendString:@"123"];
NSLog(@"变量b所指向的地址--%p,内容--%@",a,a);
NSLog(@"self.str所指向的地址--%p,内容--%@",self.str,self.str);

变量a所指向的地址--0x7fc51bca40e0,内容--One
self.str所指向的地址--0x7fc51bca40e0,内容--One

//a中追加了字符串123
变量b所指向的地址--0x7fc51bca40e0,内容--One123
self.str所指向的地址--0x7fc51bca40e0,内容--One123

上述代码中，我们声明了一个可变字符串变量a，并赋值one。当我们在变量a中追加了字符串123之后，self.str的内容也随之改变了。因为变量a和self.str所指向的地址是同一个。当我们给a追加字符串的时候，并没有重新让a指向新的地址。所以当我们给其中一个追加内容的时候，另一个也会随之改变。假如我们在某个场景中又用到了变量a，并给变量a追加了一些新的内容，就会导致self.str的内容也被改变了

接下来我们分析copy

- (void)setStr:(NSString *)str {
    _str = [str copy];
}

给字符串赋值的时候，在其内部使用拷贝的操作。我们按照之前的方式进行测试。

NSString *a = @"One";
self.str = a;
NSLog(@"变量a所指向的地址--%p,内容--%@",a,a);
NSLog(@"self.str所指向的地址--%p,内容--%@",self.str,self.str);

a = @"Two";
NSLog(@"变量a所指向的地址--%p,内容--%@",a,a);
NSLog(@"self.str所指向的地址--%p,内容--%@",self.str,self.str);

变量a所指向的地址--0x104aad088,内容--One
self.str所指向的地址--0x104aad088,内容--One

变量a所指向的地址--0x104aad0e8,内容--Two
self.str所指向的地址--0x104aad088,内容--One

从上面的代码可以看出，结果完全是和strong是一样的。但是内部是有细微差别的。再其内部的set方法中 str = [a copy] 进行了一份浅拷贝，也就是所谓的指针拷贝，使str指向了变量a所指向的地址。

接下来我们将变量a定义成可变字符串

NSMutableString *a = [NSMutableString stringWithString:@"One"];
self.str = a;
NSLog(@"变量b所指向的地址--%p",a);
NSLog(@"self.str所指向的地址--%p",self.str);
//a中追加了字符串123
[a appendString:@"123"];
NSLog(@"变量b所指向的地址--%p,内容--%@",a,a);
NSLog(@"self.str所指向的地址--%p,内容--%@",self.str,self.str);

变量a所指向的地址--0x7fc4f940fbe0
self.str所指向的地址--0xa00000000656e4f3
//a中追加了字符串123
变量a所指向的地址--0x7fc4f940fbe0,内容--One123
self.str所指向的地址--0xa00000000656e4f3,内容--One

大家是不是发现不一样的地方了？当我们在变量a中追击加了字符串之后，self.str并没有改变其内容。也就是说self.str并不会受到变量a影响。
我们仔细观察上面输出的地址。当把变量a赋值给self.str之后，打印他们的地址，我们发现self.str指向的地址不是变量a所指向的地址。这是因为当我们把变量a赋值给self.str时候，再其内部进行了一次深拷贝，也就是把整个对象进行了拷贝。
set方法内部

str = [a copy];
因为我们变量a是一个可变字符串，可变版本进行copy执行，会产生一个不可变的版本(NSString)，此时是一个深拷贝，在堆中重新开辟一个新的内存，里面存放了相同的内容One。str指向了这个新的内存地址，只是这个新对象是一个不可变的版本。所以我们看到两次输出的地址是完全不一样的。
当我们接下来给变量a追加字符串的时候，也就不会影响到self.str中的内容了。

所以定义字符串属性的时候建议使用copy关键字

2.字符串中Copy和mutableCopy操作

NSString *str = @"123";
NSString *copyStr = [str copy];
NSLog(@"str所指向的地址--%p",str);
NSLog(@"copyStr所指向的地址--%p",copyStr);

str所指向的地址--0x105e40088
copyStr所指向的地址--0x105e40088

上面的代码可以看出，当一个不可变的字符串进行copy之后返回的还是一个不可变的字符串，并且是一个浅拷贝(指针拷贝),他们还是都指向同一个地址。

NSString *str = @"123";
NSMutableString *mutableCopyStr = [str mutableCopy];
NSLog(@"str所指向的地址--%p",str);
NSLog(@"mutableCopyStr所指向的地址--%p",mutableCopyStr);

str所指向的地址--0x102859088
mutableCopyStr所指向的地址--0x7fade2e3b170

上面的代码可以看出，当一个不可变字符串进行mutableCopy之后返回一个可变的对象,进行了一次深拷贝，他们分别指向了不同的地址，只是内容还是一样的。

NSMutableString *str = [NSMutableString stringWithString:@"123"];
NSMutableString *copyStr = [str copy];
NSLog(@"str所指向的地址--%p,内容--%@",str,str);
NSLog(@"copyStr所指向的地址--%p,内容--%@",copyStr,copyStr);

str所指向的地址--0x7fcac163fc30,内容--123
copyStr所指向的地址--0xa000000003332313,内容--123

上面的代码可以看出,当一个可变字符串进行copy之后返回了一个不可变的对象，进行了一次深拷贝，他们分别指向了不同的地址，只是内容还是一样的。

NSMutableString *str = [NSMutableString stringWithString:@"123"];
NSMutableString *mutableCopyStr = [str mutableCopy];
NSLog(@"str所指向的地址--%p,内容--%@",str,str);
NSLog(@"mutableCopyStr所指向的地址--%p,内容--%@",mutableCopyStr,mutableCopyStr);

str所指向的地址--0x7fd138d0bd40,内容--123
mutableCopyStr所指向的地址--0x7fd138d0aef0,内容--123

这最后一组代码展示了，当一个可变字符串进行mutableCopy之后同样返回了一个可变的字符串，进行了一次深拷贝，他们分别指向了不同的地址，只是内容还是一样的。

从上面的四组代码可以看出，可变版本与不可变版本之间是可以互相转换的，那么到底是进行了深拷贝还是浅拷贝，不单单只能看到是执行了copy还是mutableCopy，还要结合被拷贝的对象到底是可变的还是不可变的，从而判断出到底是深拷贝还是浅拷贝

不可变版本->copy = 不可变版本（浅拷贝）

不可变版本->mutableCopy = 可变版本（深拷贝）

可变版本->copy = 不可变版本（深拷贝）

可变版本->mutableCopy = 可变版本（深拷贝）

3.数组

数组拷贝操作在日超操作中应该是用的比较多得了，接下来我们来看看关于数组部分的拷贝。

NSArray *array = @[[NSMutableString stringWithString:@"1"],[NSMutableString stringWithString:@"2"]];
NSArray *copyArray = [array copy];
NSMutableArray *mutableCopyArray = [array mutableCopy];
NSLog(@"array所指向的地址%p",array);
NSLog(@"copyArray所指向的地址%p",copyArray);
NSLog(@"mutableCopyArray所指向的地址%p",mutableCopyArray);
NSLog(@"array第一个元素所指向的地址%p，array第二个元素所指向的地址%p",array[0],array[1]);
NSLog(@"copyArray第一个元素所指向的地址%p，copyArray第二个元素所指向的地址%p",copyArray[0],copyArray[1]);
NSLog(@"mutableCopyArray第一个元素所指向的地址%p，mutableCopyArray第二个元素所指向的地址%p",mutableCopyArray[0],mutableCopyArray[1]);

array所指向的地址0x7f92a8ead290
copyArray所指向的地址0x7f92a8ead290
mutableCopyArray所指向的地址0x7f92a8eacf70

array中第一个元素所指向的地址0x7f92a8eaa870，array中第二个元素所指向的地址0x7f92a8e1dca0
copyArray中第一个元素所指向的地址0x7f92a8eaa870，copyArray中第二个元素所指向的地址0x7f92a8e1dca0
mutableCopyArray中第一个元素所指向的地址0x7f92a8eaa870，mutableCopyArray中第二个元素所指向的地址0x7f92a8e1dca0

我们观察上述代码和打印出来的地址，当NSArray进行copy之后返回了一个不可变的NSArray，他们所指向的地址都是同一个,进行了浅拷贝。然后当NSArray进行mutableCopyArray之后返回了一个可变的数组NSMutableArray，他们指向了不同的地址。和上一节中字符串结论是一致的。
接下来我们看数组中得元素，我们发现不管是进行了copy还是mutableCopy，这些元素的地址都没有变过，说明数组中得元素都是进行了浅拷贝，进行了指针拷贝而已。为了进一步证实这个说法。我们接下来修改数组中得元素：

    //给第一个元素中追加字符串one，然后分别打印这几个数组
    [array[0] appendString:@"one"];
    NSLog(@"%@",array);
    NSLog(@"%@",copyArray);
    NSLog(@"%@",mutableCopyArray);
    
2015-11-26 15:45:11.632 NSCopying[3379:206715] (
    1one,
    2
)
2015-11-26 15:45:11.632 NSCopying[3379:206715] (
    1one,
    2
)
2015-11-26 15:45:11.632 NSCopying[3379:206715] (
    1one,
    2
)

我们可以看到每一份数组的中第一个元素都发生了变化。这也说明了数组中的元素只是进行了一份浅拷贝。

//接着上面的代码，我们向mutableCopyArray添加一点元素
[mutableCopyArray addObject:[NSMutableString stringWithString:@"3"]];
NSLog(@"array--%@",array);
NSLog(@"copyArray--%@",copyArray);
NSLog(@"mutableCopyArray--%@",mutableCopyArray);

2015-11-26 15:56:38.776 NSCopying[3455:212121] array--(
    1,
    2
)
2015-11-26 15:56:38.776 NSCopying[3455:212121] copyArray--(
    1,
    2
)
2015-11-26 15:56:38.776 NSCopying[3455:212121] mutableCopyArray--(
    1,
    2,
    3
)

根据上一节字符串中结论，mutableCopyArray它是一个深拷贝，所以给它添加元素，并不会影响其他两个数组中得元素。

//我们给mutableCopyArray中第一个元素赋值一个新的字符串，并打印
mutableCopyArray[0] = [NSMutableString stringWithString:@"123"];
NSLog(@"array--%@",array);
NSLog(@"copyArray--%@",copyArray);
NSLog(@"mutableCopyArray--%@",mutableCopyArray);

2015-11-26 16:04:07.464 NSCopying[3486:215020] array--(
    1,
    2
)
2015-11-26 16:04:07.464 NSCopying[3486:215020] copyArray--(
    1,
    2
)
2015-11-26 16:04:07.465 NSCopying[3486:215020] mutableCopyArray--(
    123,
    2,
    3
)

上面的代码创建了一个新的NSMutableString对象并将其内存地址赋给指针mutableCopyArray[0]，而其他数组指针指向的对象不变，所以输出时其他数组不受影响。

//接下来我们删除mutableCopyArray中第二个元素，并打印
[mutableCopyArray removeObjectAtIndex:1];
NSLog(@"array--%@",array);
NSLog(@"copyArray--%@",copyArray);
NSLog(@"mutableCopyArray--%@",mutableCopyArray);

2015-11-26 16:10:03.562 NSCopying[3509:217545] array--(
    1,
    2
)
2015-11-26 16:10:03.563 NSCopying[3509:217545] copyArray--(
    1,
    2
)
2015-11-26 16:10:03.563 NSCopying[3509:217545] mutableCopyArray--(
    1
）

移除的是mutableCopyArray指向的索引结合中的第二个元素，即移除的是对对象的引用，而不是移除数组中的第二个对象。并不会会影响到array，copyArray。

总结：对于数组进行的copy和mutableCopy结论可以参照上一节中字符串结论，数组特殊地方在于其内部的元素，只是进行了简单的浅拷贝，如果数组中得元素它是一个可变对象，比如一个可变字符串，如果你追加了字符串，再或者可以是一个自定义的类，你修改其中某一个属性，其他的数组中得元素也会随之受到相同的修改

4.字典

关于字典拷贝，原理和上一节的数组是一样的，而且其内部的value也是浅拷贝。

NSDictionary *dict = @{@"key1":[NSMutableString stringWithString:@"1"],@"key2":[NSMutableString stringWithString:@"2"]};
NSDictionary *copyDict = [dict copy];
NSMutableDictionary *mutableCopyDict = [dict mutableCopy];

NSLog(@"dict所指向的地址%p",dict);
NSLog(@"copyDict所指向的地址%p",copyDict);
NSLog(@"mutableCopyDict所指向的地址%p",mutableCopyDict);

NSLog(@"%p",dict[@"key1"]);
NSLog(@"%p",copyDict[@"key1"]);
NSLog(@"%p",mutableCopyDict[@"key1"]);

2015-11-26 16:37:31.952 NSCopying[3619:229287] dict所指向的地址0x7fcab0e6c250
2015-11-26 16:37:31.953 NSCopying[3619:229287] copyDict所指向的地址0x7fcab0e6c250
2015-11-26 16:37:31.953 NSCopying[3619:229287] mutableCopyDict所指向的地址0x7fcab0e6c290
2015-11-26 16:37:31.953 NSCopying[3619:229287] 0x7fcab0e689a0
2015-11-26 16:37:31.954 NSCopying[3619:229287] 0x7fcab0e689a0
2015-11-26 16:37:31.954 NSCopying[3619:229287] 0x7fcab0e689a0

字典对象间的拷贝还是遵循第一节中字符串那个结论，根据打印出来的地址可以看出，字典内部的value值和数组中得元素一样都是进行了浅拷贝。

//给dict[@"key1"]追加字符串
[dict[@"key1"] appendString:@"one"];
NSLog(@"dict%@",dict);
NSLog(@"copyDict%@",copyDict);
NSLog(@"mutable%@",mutableCopyDict);

2015-11-26 16:42:19.316 NSCopying[3657:231891] dict{
    key1 = 1one;
    key2 = 2;
}
2015-11-26 16:42:19.821 NSCopying[3657:231891] copyDict{
    key1 = 1one;
    key2 = 2;
}
2015-11-26 16:42:23.133 NSCopying[3657:231891] mutable{
    key1 = 1one;
    key2 = 2;
}

因为value是浅拷贝，value又是可变字符串转，当追加字符串进去的时候，其他字典也会随之受到影响。

//我们给mutableCopyDict中添加一个key-value
[mutableCopyDict setObject:@"3" forKey:@"key3"];
NSLog(@"dict%@",dict);
NSLog(@"copyDict%@",copyDict);
NSLog(@"mutable%@",mutableCopyDict);

2015-11-26 16:46:07.813 NSCopying[3678:234004] dict{
    key1 = 1;
    key2 = 2;
}
2015-11-26 16:46:07.813 NSCopying[3678:234004] copyDict{
    key1 = 1;
    key2 = 2;
}
2015-11-26 16:46:07.813 NSCopying[3678:234004] mutable{
    key1 = 1;
    key2 = 2;
    key3 = 3;
}

跟上一节的数组原理一样，mutableCopyDict本身是一个深拷贝，所以给它内部添加元素，对应删除元素，都不会影响到其他几个字典。提醒：字典中得key你会发现它必须实现NSCopying协议，所以key它本身也进行了拷贝，为什么要这么做，大家自己去思考吧。

小结：可变与不可变对象是可以互相转换的。数组中的元素和字典中得value都是进行了浅拷贝，如果想实现深拷贝，需要自己额外的去实现了。

最后编辑于：2017.11.27 04:52:43

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 206,214评论 6赞 481
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 88,307评论 2赞 382
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 152,543评论 0赞 341
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 55,221评论 1赞 279
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 64,224评论 5赞 371
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,007评论 1赞 284
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,313评论 3赞 399
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,956评论 0赞 259
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 43,441评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,925评论 2赞 323
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,018评论 1赞 333
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,685评论 4赞 322
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,234评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,240评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,464评论 1赞 261
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,467评论 2赞 352
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,762评论 2赞 345