blocks|key|214343|text|在浅层克隆中，克隆类不复制其内部对象，但在深度克隆中，类的所有内部对象也被复制。深度克隆的一个缺点似乎是序列化，这类克隆对象的序列化并不是那么容易。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|214344|然而，不能说哪一个更好。|214345|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In shallow cloning, cloned class doesn't copy its internal objects but in deep cloning all internal objects of the class are also copied.
One disadvantage of deep cloning that seem is with serialization, that serialization of such cloned object is not that easier. 
However it can not be said which is better.

blocks|key|1274318|text|这取决于你想要实现什么：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1274319|如果您希望获得对相同对象的引用列表，并且只想以某种方式避免使用ConcurrentModificationException，则可以使用浅克隆。|offset|length|style|BOLD|1274320|如果您想要一整堆具有相同值的新对象，则需要进行深入的克隆。|1274321|entityMap^0|0|V|V|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

It depends on what you want to achieve:

If you want a list of references to the same objects and just want to somehow avoid the
ConcurrentModificationException than you could use shallow cloning.

If you want a whole bunch of new objects with just the same values inside you need deep cloning.

blocks|key|1274356|text|浅拷贝:通常是对象的克隆方法，创建同一个类的新实例，并将所有字段复制到新实例并返回它。这不过是浅薄的抄袭。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1274357|深度克隆|1274358|在大多数情况下，这是人们想要的行为。我们想要一个独立于原作的克隆，在克隆中的改变不应该影响原作。|1274359|您也可以考虑复制构造函数。|1274360|至于你的问题，哪一个会更好，这取决于你总是在寻找什么样的行为。|1274361|克隆简介:http://howtodoinjava.com/2012/11/08/a-guide-to-object-cloning-in-java/|offset|length|1274362|entityMap|0|LINK|mutability|MUTABLE|url|http://howtodoinjava.com/2012/11/08/a-guide-to-object-cloning-in-java/^0|0|0|0|0|0|5|1Y|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|10|8|@]|9|@$L|11|M|12|1|13]]|A|$]]|$1|N|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]]]

Shallow Copy:
Generally clone method of an object, creates a new instance of the same class and copies all the fields to the new instance and returns it. This is nothing but shallow copy.

Deep cloning

It is the desired behavior in most the cases. We want a clone which is independent of original and making changes in clone should not affect original.

you can think of copy constructor as well.

and aboput your question which one will be better, It depends on what behaviour you always looks for.

A brif introduction about cloning :<a href="http://howtodoinjava.com/2012/11/08/a-guide-to-object-cloning-in-java/" rel="nofollow">http://howtodoinjava.com/2012/11/08/a-guide-to-object-cloning-in-java/</a>

blocks|key|214388|text|假设b类是从类中克隆出来的。如果使用类所做的任何更改都影响到b类，那么在类中所做的任何更改都不影响b类，则称为深度克隆。因为在阴影克隆中，b类指向a+class..it共享相同的内存位置。在深度克隆中，将创建单独的副本。这意味着a类和b类将具有独立的内存位置。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|214389|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Consider b class has been cloned from a class..
If any changes done with a class affects b class,then it is shadow copy..if any changes done in a class does not affect b class,then it is called deep cloning..
Because in shadow cloning b class points to the a class..it shares the same memory location..
In deep cloning, seperate copy will be created..
It means a class and b class will have seperate memory location..

blocks|key|214405|text|浅层克隆和深度克隆都是有用的。如果您有一个类实例不包含任何其他类的引用，那么最好做一个浅拷贝，但是如果有其他类的实例被我们的具体类使用，那么我们应该选择深度克隆，否则就无法实现完全的克隆。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|214406|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

well, both shallow cloning and deep cloning are useful. If you have a single class instance which doesn't hold the reference of any other class then it's better to make a shallow copy but if there are some other class whose instance is used by our concrete class then we should choose deep cloning otherwise complete cloning cant be achieved.

blocks|key|214414|text|这取决于您的需求，要么您需要一个内部指向相同对象的不同对象，要么您需要一个副本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|214415|浅克隆是Object.clone()方法提供的默认克隆策略。浅克隆策略创建一个新实例，并将给定对象的所有字段复制到该新实例(它要么是原始实例，要么是引用)。因此，在引用类型的情况下，只有引用位被复制到新实例，因此，两个对象的引用变量将指向同一个对象。|offset|length|style|BOLD|CODE|214416|深度克隆，顾名思义，深度克隆意味着将所有东西从一个对象克隆到另一个对象。要实现这一点，您将需要欺骗您的克隆()方法，提供您自己的克隆策略。您可以通过在对象层次结构中的每种引用类型中实现Cloneable接口和重写克隆()方法来实现它，然后在对象的克隆方法中调用super.clone()和这些克隆()方法。|214417|public+Person+clone()+throws+CloneNotSupportedException+{
++++Person+clonedObj+=+(Person)+super.clone();
++++clonedObj.city+=+this.city.clone();
++++return+clonedObj;
}|code-block|syntax|javascript|214418|要知道更多，你可以检查Java克隆和类型(浅和深)的详细说明，并举例说明|214419|entityMap|0|LINK|mutability|MUTABLE|url|https://programmingmitra.blogspot.in/2016/11/Java-Cloning-Types-of-Cloning-Shallow-Deep-in-Details-with-Example.html^0|0|0|3|4|E|0|0|4|0|0|B|P|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@$D|11|E|12|F|G]|$D|13|E|14|F|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|15|8|@$D|16|E|17|F|G]]|9|@]|A|$]]|$1|K|3|L|5|M|7|18|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|6|7|19|8|@]|9|@$D|1A|E|1B|1|1C]]|A|$]]|$1|R|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|Y]]]]

It depends on your requirement, either you need a different object which is internally pointing the same objects or you need a duplicate 

Shallow Cloning is the default cloning strategy provided by <code>Object.clone()</code> method. Shallow cloning strategy creates a new instance and copies all fields of the given object to that new instance (either it is primitive or reference). So in the case of reference types only reference bits gets copied to the new instance, therefore, a reference variable of both objects will point to the same object.

Deep Cloning As the name suggest deep cloning means cloning everything from one object to another object. To achieve this you will need to trick your clone() method provide your own cloning strategy. You can do it by implementing Cloneable interface and override clone() method in every reference type we have in our object hierarchy and then call super.clone() and these clone() methods in our object’s clone method.

<pre><code>public Person clone() throws CloneNotSupportedException {
 Person clonedObj = (Person) super.clone();
 clonedObj.city = this.city.clone();
 return clonedObj;
}
</code></pre>

To know more youu can check <a href="https://programmingmitra.blogspot.in/2016/11/Java-Cloning-Types-of-Cloning-Shallow-Deep-in-Details-with-Example.html" rel="nofollow noreferrer">Java Cloning and Types of Cloning (Shallow and Deep) in Details with Example</a>

I have a little confusion about object cloning in java. What is the main difference between shallow cloning and deep cloning?

And which is much better ?

What is better shallow or deep cloning?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

对于java中的对象克隆，我有点困惑。浅克隆和深克隆的主要区别是什么？哪一个更好？

问什么是浅层的还是深度的克隆？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是浅层的还是深度的克隆？EN