iOS 关于容器类的浅、深拷贝探究

引子

浅拷贝：指针拷贝，引用拷贝，指向同一内存地址

深拷贝：内容拷贝，指向不同内存地址，但是内容相同

容器类拷贝的误解

针对NSArray，copy是浅拷贝，mutableCopy是深拷贝

针对NSMutableArray，copy是深拷贝，mutableCopy是深拷贝

举例说明：

NSArray的拷贝

NSArray *itemsOrigin = @[@"apple",@"pear"];
NSArray *items_copy = itemsOrigin.copy;
NSArray *items_mutableCopy = itemsOrigin.mutableCopy;
NSLog(@"原始数组地址：%p",itemsOrigin);
NSLog(@"copy数组地址：%p",items_copy);
NSLog(@"mutableCopy数组地址：%p",items_mutableCopy);

输出的内存地址：

结果

看来似乎没什么问题，copy后的数组指向同一内存地址，mutableCopy产生新的内存地址

NSMutableArray的拷贝

NSMutableArray *mutableItemsOrigin = [NSMutableArray arrayWithArray:@[@"apple",@"pear"]];
NSArray *mutableItems_copy = mutableItemsOrigin.copy;
NSMutableArray *mutableItems_mutableCopy = mutableItemsOrigin.mutableCopy;
NSLog(@"原始数组地址：%p",mutableItemsOrigin);
NSLog(@"copy数组地址：%p",mutableItems_copy);
NSLog(@"mutableCopy数组地址：%p",mutableItems_mutableCopy);

输出的内存地址：

结果

这和误解中说的一致，针对NSMutableArray，copy是深拷贝，mutableCopy是深拷贝

但是我们不要忘了，深拷贝的意义在于，内容完全的复制，解决引用的问题，当我们改变其中一个元素时，相互不会影响

这里有人会反驳了，我改变了元素，的确不会影响到复制的数组，就像下面这样：

// 改变原始数组
[mutableItemsOrigin addObject:@"banana"];
// 改变mutableCopy数组
[mutableItems_mutableCopy addObject:@"grape"];
NSLog(@"原始数组元素：%@",mutableItemsOrigin);
NSLog(@"mutableCopy数组元素：%@",mutableItems_mutableCopy);

输出：

结果

似乎没啥问题，确实相互不会影响，说到这里，有人可能会大骂LZSB！

那是不是笔者哗众取宠了呢？回答是NO，让笔者一步步揭开容器类真正的深拷贝

首先，我们回到最初的数组，输出它们的内存地址

NSMutableArray *mutableItemsOrigin = [NSMutableArray arrayWithArray:@[@"apple",@"pear"]];
NSArray *mutableItems_copy = mutableItemsOrigin.copy;
NSMutableArray *mutableItems_mutableCopy = mutableItemsOrigin.mutableCopy;
NSLog(@"原始数组地址：%p",mutableItemsOrigin);
NSLog(@"copy数组地址：%p",mutableItems_copy);
NSLog(@"mutableCopy数组地址：%p",mutableItems_mutableCopy);
        
NSLog(@"\n");
for (NSString *itemString in mutableItemsOrigin) {
    NSLog(@"原始数组元素地址：%p",itemString);
}
for (NSString *itemString in mutableItems_copy) {
    NSLog(@"copy数组元素地址：%p",itemString);
}
for (NSString *itemString in mutableItems_mutableCopy) {
    NSLog(@"mutableCopy数组元素地址：%p",itemString);
}

输出元素内存地址：

结果

由上图可知，容器数组无论是copy还是mutableCopy，元素指向了相同的内存地址；由此可知，两种拷贝方式仅仅产生了两个内存地址不同的容器，它们的使用的是同一份元素

那为什么内容不相互影响呢？接着往下看
我们为原始数组新增一个元素，mutableCopy的数组作删除一个元素操作

// 改变原始数组 -- 新增
[mutableItemsOrigin addObject:@"banana"];
// 改变mutableCopy数组 -- 删除
[mutableItems_mutableCopy removeLastObject];
NSLog(@"原始数组元素：%@",mutableItemsOrigin);
NSLog(@"mutableCopy数组元素：%@",mutableItems_mutableCopy);
NSLog(@"\n");
for (NSString *itemString in mutableItemsOrigin) {
    NSLog(@"原始数组元素地址：%p",itemString);
}
for (NSString *itemString in mutableItems_mutableCopy) {
    NSLog(@"mutableCopy数组元素地址：%p",itemString);
}

输出：

结果

由上图可知：

1、原始数组新增了一个内存地址为：0x100002130，内容为banana的元素，mutableCopy数组只剩内存地址为0x100002090，内容为apple的元素

2、原始数组和mutableCopy数组确实没有相互影响

原因解析

最初的时候

结果

当我们操作数组中的元素时（原始数组新增一个元素，mutableCopy的数组作删除一个元素操作），会发生如下变化

结果

上图可以看出，原始数组多出了一个“banana”的元素，而可变数组被删除了“pear”元素，指向“pear”元素的指针被移除了

过程虽然如此，但是并没有影响到我们使用，那我们是不是忽略其非深拷贝到事实了呢？错，我们要知道，上述的例子中，元素都是不可变的，当我们操作时，都是操作了整个元素地址，要么被删除（指针），要么新增元素（新地址），假如元素是可变的，我们只操作元素的子元素会发生什么呢？

重点：操作可变数组可变元素

我们将元素定义为可变的

// 定义一个可变元素数组
NSMutableArray *items = [NSMutableArray arrayWithArray:@[@"apple",@"pear"]];
// 新建原始数组
NSMutableArray *mutableItemsOrigin = [NSMutableArray arrayWithObject:items];
// copy该数组
NSArray *mutableItems_copy = mutableItemsOrigin.copy;
// mutableCopy该数组
NSMutableArray *mutableItems_mutableCopy = mutableItemsOrigin.mutableCopy;
NSLog(@"原始数组地址：%p",mutableItemsOrigin);
NSLog(@"copy数组地址：%p",mutableItems_copy);
NSLog(@"mutableCopy数组地址：%p",mutableItems_mutableCopy);
// 输出元素的内存地址
NSLog(@"\n");
for (NSMutableArray *items in mutableItemsOrigin) {
    for (NSString *itemString in items) {
        NSLog(@"原始数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_copy) {
    for (NSString *itemString in items) {
        NSLog(@"copy数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_mutableCopy) {
    for (NSString *itemString in items) {
        NSLog(@"mutableCopy数组元素地址：%p",itemString);
    }
}

输出内存地址：

结果

由上图可知：同样的，NSMutableArray数组的copy和mutableCopy都会产生内存地址不同容器，但是元素依旧引用了同一份，属于浅拷贝

接下来，我们来改变其中可变元素

// 改变原始数组 -- 新增
NSMutableArray *tmpItemsOrigin = mutableItemsOrigin.firstObject;
[tmpItemsOrigin addObject:@"banana"];
// 改变mutableCopy数组 -- 新增
NSMutableArray *tmpItems_mutableCopy = mutableItems_mutableCopy.firstObject;
[tmpItems_mutableCopy addObject:@"watermelon"];
NSLog(@"原始数组元素：%@",mutableItemsOrigin.firstObject);
NSLog(@"copy数组元素：%@",mutableItems_copy.firstObject);
NSLog(@"mutableCopy数组元素：%@",mutableItems_mutableCopy.firstObject);

for (NSMutableArray *items in mutableItemsOrigin) {
    for (NSString *itemString in items) {
        NSLog(@"原始数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_copy) {
    for (NSString *itemString in items) {
        NSLog(@"copy数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_mutableCopy) {
    for (NSString *itemString in items) {
        NSLog(@"mutableCopy数组元素地址：%p",itemString);
    }
}

输出结果：

结果

我们看到，上述操作，无论是原始数组的新增，还是mutableCopy数组的新增都会相互影响，不仅如此，copy出来的不可变数组也被改变了！！

这种结果再次说明，容器类的复制，无论是copy还是mutableCopy，如果仅仅做一次拷贝就是浅拷贝！！！

接下来，我们来看下系统的一个方法，拷贝元素

- (instancetype)initWithArray:(NSArray<ObjectType> *)array copyItems:(BOOL)flag

这个方法是将items拷贝（copy）一份，不可变元素为浅拷贝，可变元素则为深拷贝容器

1、items为NSArray

MutableArray *mutableItemsOrigin = [NSMutableArray arrayWithObject:@[@"apple",@"pear"]];
NSArray *mutableItems_copy = [[NSArray alloc] initWithArray:mutableItemsOrigin copyItems:YES];
NSMutableArray *mutableItems_mutableCopy = [[NSMutableArray alloc] initWithArray:mutableItemsOrigin copyItems:YES];
NSLog(@"原始数组地址：%p",mutableItemsOrigin);
NSLog(@"copy数组地址：%p",mutableItems_copy);
NSLog(@"mutableCopy数组地址：%p",mutableItems_mutableCopy);

NSLog(@"\n");
NSLog(@"原始数组元素地址：%p",mutableItemsOrigin.firstObject);
NSLog(@"copy数组元素地址：%p",mutableItems_copy.firstObject);
NSLog(@"mutableCopy数组元素地址：%p",mutableItems_mutableCopy.firstObject);

结果：元素的内存地址不变

结果

2、items为NSMutableArray

MutableArray *items = [NSMutableArray arrayWithArray:@[@"apple",@"pear"]];

NSMutableArray *mutableItemsOrigin = [NSMutableArray arrayWithObject:items];
NSArray *mutableItems_copy = [[NSArray alloc] initWithArray:mutableItemsOrigin copyItems:YES];
NSMutableArray *mutableItems_mutableCopy = [[NSMutableArray alloc] initWithArray:mutableItemsOrigin copyItems:YES];
NSLog(@"原始数组地址：%p",mutableItemsOrigin);
NSLog(@"copy数组地址：%p",mutableItems_copy);
NSLog(@"mutableCopy数组地址：%p",mutableItems_mutableCopy);

NSLog(@"\n");
NSLog(@"原始数组元素地址：%p",mutableItemsOrigin.firstObject);
NSLog(@"copy数组元素地址：%p",mutableItems_copy.firstObject);
NSLog(@"mutableCopy数组元素地址：%p",mutableItems_mutableCopy.firstObject);

结果：元素变为不可变数组，内存地址改变

结果

这样，我们来重复之前的例子

MutableArray *items = [NSMutableArray arrayWithArray:@[@"apple",@"pear"]];

NSMutableArray *mutableItemsOrigin = [NSMutableArray arrayWithObject:items];
NSArray *mutableItems_copy = [[NSArray alloc] initWithArray:mutableItemsOrigin copyItems:YES];
NSMutableArray *mutableItems_mutableCopy = [[NSMutableArray alloc] initWithArray:mutableItemsOrigin copyItems:YES];
NSLog(@"原始数组地址：%p",mutableItemsOrigin);
NSLog(@"copy数组地址：%p",mutableItems_copy);
NSLog(@"mutableCopy数组地址：%p",mutableItems_mutableCopy);

NSLog(@"\n");
// 输出元素地址
NSLog(@"原始数组元素地址：%p",mutableItemsOrigin.firstObject);
NSLog(@"copy数组元素地址：%p",mutableItems_copy.firstObject);
NSLog(@"mutableCopy数组元素地址：%p",mutableItems_mutableCopy.firstObject);
// 输出最小元素地址
for (NSMutableArray *items in mutableItemsOrigin) {
    for (NSString *itemString in items) {
        NSLog(@"原始数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_copy) {
    for (NSString *itemString in items) {
        NSLog(@"copy数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_mutableCopy) {
    for (NSString *itemString in items) {
        NSLog(@"mutableCopy数组元素地址：%p",itemString);
    }
}

结果：

结果

我们发现：

1、使用了copyItems函数后，产生了新的元素容器，但是最小元素的内存地址依旧是一份

2、可变元素数组由于该函数，变为了不可变数组

3、最小单位的元素依旧指向同一份地址

这时，由于元素数组内存地址已经不同，我们操作原始数组时，不会在影响到拷贝到数组

// 改变原始数组 -- 新增
NSMutableArray *tmpItemsOrigin = mutableItemsOrigin.firstObject;
[tmpItemsOrigin addObject:@"banana"];
// 改变mutableCopy数组 -- 新增 -- 由于元素变为不可变数组，所以不可像下面那样操作
//NSMutableArray *tmpItems_mutableCopy = mutableItems_mutableCopy.firstObject;
//[tmpItems_mutableCopy addObject:@"watermelon"];
NSLog(@"原始数组元素：%@",mutableItemsOrigin.firstObject);
NSLog(@"copy数组元素：%@",mutableItems_copy.firstObject);
NSLog(@"mutableCopy数组元素：%@",mutableItems_mutableCopy.firstObject);

for (NSMutableArray *items in mutableItemsOrigin) {
    for (NSString *itemString in items) {
        NSLog(@"原始数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_copy) {
    for (NSString *itemString in items) {
        NSLog(@"copy数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_mutableCopy) {
    for (NSString *itemString in items) {
        NSLog(@"mutableCopy数组元素地址：%p",itemString);
    }
}

结果：

结果

copy的数组和mutableCopy数组并未被影响

系统提供的这种方法只不过就是元素数组copy一下，并将数组转换为不可变数组NSArray，这时操作了整个不可变元素数组，这样就避免了相互影响（和操作NSArray一样）

综上所述

1、copy和mutableCopy只能作单层拷贝，针对容器类仅仅使用一次拷贝操作时，只能产生新的容器，但是元素共用一份

2、如果想要拷贝元素，则需要调用系统方法copyItems，将元素copy一份（这个元素copy也仅仅是单层拷贝）

3、如果是容器嵌套容器时，单单使用一次copy或者mutableCopy，严格意义上来说，是无法做到深拷贝的，因为元素可能没有被拷贝，并且如果元素是不可变类型时，无论怎么样做都只能是引用拷贝，因为最小元素是不可变的，仅仅有一份内存地址

4、因此非容器类，如NSString，NSMutableString等，copy和mutableCopy作单层拷贝就达到了最终效果

验证

情况1：非容器类，不可变类型

NSString *string = @"LOLITA64";
NSString *string_copy = string.copy;
NSMutableString *string_mutableCopy = string.mutableCopy;
NSLog(@"string地址：%p",string);
NSLog(@"string_copy地址：%p",string_copy);
NSLog(@"string_mutableCopy地址：%p",string_mutableCopy);
[string_mutableCopy appendString:@"-test"];
NSLog(@"原始字符串：%@",string);
NSLog(@"string_copy字符串：%@",string_copy);
NSLog(@"string_mutableCopy字符串：%@",string_mutableCopy);

输出：

结果

结论：copy为浅拷贝，mutableCopy为深拷贝

情况2：非容器类，可变类型

NSString *string = [NSMutableString stringWithString:@"LOLITA64"];
NSString *string_copy = string.copy;
NSMutableString *string_mutableCopy = string.mutableCopy;
NSLog(@"string地址：%p",string);
NSLog(@"string_copy地址：%p",string_copy);
NSLog(@"string_mutableCopy地址：%p",string_mutableCopy);
[string_mutableCopy appendString:@"-test"];
NSLog(@"原始字符串：%@",string);
NSLog(@"string_copy字符串：%@",string_copy);
NSLog(@"string_mutableCopy字符串：%@",string_mutableCopy);

输出：

结果

结论：copy为深拷贝，mutableCopy为深拷贝

情况3：容器类（单层），不可变类型，元素不可变非容器，单次拷贝

NSArray *items = @[@"apple",@"pear"];
NSArray *items_copy = items.copy;
NSMutableArray *items_mutableCopy = items.mutableCopy;
NSLog(@"items地址：%p",items);
NSLog(@"items_copy地址：%p",items_copy);
NSLog(@"items_mutableCopy地址：%p",items_mutableCopy);
for (NSString *itemString in items) {
    NSLog(@"items不可变元素地址：%p",itemString);
}
for (NSString *itemString in items_copy) {
    NSLog(@"items_copy不可变元素地址：%p",itemString);
}
for (NSString *itemString in items_mutableCopy) {
    NSLog(@"items_mutableCopy不可变元素地址：%p",itemString);
}

输出：

结果

结论：copy不产生新容器，mutableCopy产生新容器，但是最小元素内存地址都一样，浅拷贝

情况4：容器类（单层），不可变类型，元素不可变非容器，元素拷贝

// 更改
NSArray *items_copy = [[NSArray alloc] initWithArray:items copyItems:YES];
NSMutableArray *items_mutableCopy = [[NSMutableArray alloc] initWithArray:items copyItems:YES];

输出：

结果

结论：产生新容器，但是最小元素内存地址都一样，浅拷贝

情况5：容器类（单层），不可变类型，元素可变非容器，单次拷贝

NSMutableString *string1 = [NSMutableString stringWithString:@"apple"];
NSMutableString *string2 = [NSMutableString stringWithString:@"pear"];
NSArray *items = @[string1,string2];
NSArray *items_copy = items.copy;
NSMutableArray *items_mutableCopy = items.mutableCopy;

结果：

结果

结论：copy不产生新容器，mutableCopy产生新容器，但是最小元素内存地址都一样，浅拷贝

情况6：容器类（单层），不可变类型，元素可变非容器，元素拷贝

NSArray *items_copy = [[NSArray alloc] initWithArray:items copyItems:YES];
NSMutableArray *items_mutableCopy = [[NSMutableArray alloc] initWithArray:items copyItems:YES];

输出：

结果

结论：产生新容器，最小元素内存地址不一样，深拷贝

情况7：容器类（单层），可变类型，元素不可变非容器，单次拷贝

NSMutableArray *items = [NSMutableArray arrayWithArray:@[@"apple",@"pear"]];
NSArray *items_copy = items.copy;
NSMutableArray *items_mutableCopy = items.mutableCopy;

输出：

结果

结论：copy、mutableCopy都产生新容器，但是最小元素内存地址都一样，浅拷贝

情况8：容器类（单层），可变类型，元素不可变，元素拷贝

NSMutableArray *items = [NSMutableArray arrayWithArray:@[@"apple",@"pear"]];
NSArray *items_copy = [[NSArray alloc] initWithArray:items copyItems:YES];
NSMutableArray *items_mutableCopy = [[NSMutableArray alloc] initWithArray:items copyItems:YES];

输出：

结果

结论：copy、mutableCopy都产生新容器，但是最小元素内存地址都一样，浅拷贝

情况9：容器类（单层），可变类型，元素可变，单次拷贝

NSMutableString *string1 = [NSMutableString stringWithString:@"apple"];
NSMutableString *string2 = [NSMutableString stringWithString:@"pear"];
NSMutableArray *items = [NSMutableArray arrayWithArray:@[string1,string2]];
NSArray *items_copy = items.copy;
NSMutableArray *items_mutableCopy = items.mutableCopy;

输出：

结果

结论：copy、mutableCopy都产生新容器，但是最小元素内存地址都一样，浅拷贝

情况10：容器类（单层），可变类型，元素可变，元素拷贝

NSArray *items_copy = [[NSArray alloc] initWithArray:items copyItems:YES];
NSMutableArray *items_mutableCopy = [[NSMutableArray alloc] initWithArray:items copyItems:YES];

输出：

结果

结论：产生新容器，最小元素内存地址不一样，深拷贝

情况11：容器类（多层，嵌套容器）

参考开始几个例子

结论：

1、容器类是否可以深拷贝，首先要看最小元素，若最小元素为不可变类型，容器类的任何拷贝操作都是浅拷贝

2、如使用copyItems函数，并且元素为可变类型时，可以连元素一起拷贝，属于深拷贝（元素非容器）

最后编辑于：2017.12.11 05:14:30

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

iOS 关于容器类的浅、深拷贝探究

推荐阅读更多精彩内容