在Java中，什么是浅拷贝？

Question

java.util.Calendar.clone() 返回“...具有相同属性的新日历”并返回“此日历的浅表副本”。

这似乎不是回答的浅拷贝

在Java中，什么是浅拷贝？

它与 Java 深拷贝（如果存在）有何不同？

Answer 1

浅拷贝：在此克隆中，对克隆对象的任何更改也会反映到原始对象。

深度复制：在此克隆中，会分配单独的克隆内存，这意味着对克隆对象的任何更改都不会反映到原始对象。

Answer 2

在浅拷贝中，克隆对象具有原始值的副本，但对象引用引用与原始副本相同的对象。
浅拷贝有一个显着的缺点，克隆对象和原始副本引用相同的地址对象。 克隆对象在地址对象中所做的任何更改也将反映在原始副本中，这是一种不需要的行为。 我们真正想要的是用户对象的两个单独的副本。 深度复制可以解决这种情况。

深度复制不仅克隆原始值，还创建对象引用的副本。

您可以在此处查看有关此问题的工作示例：https： //codingninjaonline.com/2017/11/09/deep-vs-shallow-copy/

Answer 3

浅拷贝只是将对象引用复制到目标引用中。 它不会在堆上创建新对象。
默认情况下，Java 使用clone() 函数进行浅克隆。

为了在堆上获取一个新对象，必须执行深度克隆，这可以通过序列化和反序列化来实现。

Answer 4

首先，如果我们谈论一维数组，ArrayList 的 Javadoc 就有些错误，因为它使用了数组中的 copyOf 方法。 所以clone()返回一个一维副本，至少从1.5开始（我没有进一步测试）！ 这就是 Java 中“浅层”的含义：一维

您可以在此处阅读更多内容： http://www.javapractices.com/topic/TopicAction.do?Id=3。 所以clone()不是浅拷贝！ 如果你想要一维数组的真正浅拷贝，只需引用它：

Array a = new Array();
Array b = a;                    //a is only a shallow copy, nice for synchronisation

Java 中的数组很棘手，也是因为 Java 确实是按值传递的，但数组的值只是它们的指针！ 另一方面，这允许我们同步对象，这是一件很棒的事情。 尽管如此，如果您在数组（或 ArrayList）中使用数组，仍然会出现一些问题，因为容器数组（或 ArrayList）的 clone() 不会复制它们的值，只会复制它们的引用！ 所以你根本不应该将任何数组放入数组中，你应该只处理数组中的对象！

而且 Javadoc 有时很难理解，所以尝试一下测试...

玩得开心！

Answer 5

您从哪里获得此文档？

java.sun.com 上的官方 Java 6 文档只有 Calendar.clone()< /a> 返回对象的副本。 没有提到浅薄。

更一般地说，Java 中的浅复制是一种获得新对象引用的复制，但新对象（直接或间接）保存对原始对象中数据的引用。

例如：

class MyClass{
  private List<Integer> innerList;

  public MyClass(List<Integer> list) { innerList = list; }

  //Some code...

  public Object clone(){
    return new MyClass(innerList);
  }
}

在其clone()中返回一个浅拷贝。

Answer 6

浅拷贝是通过引用传递......
深度复制是按值传递……
上下文不同，但过程完全相同。 首先记住，在Java方法调用中，基元是按值传递的，而对象是按引用传递的（在其他语言中，对象也可能是按值传递的）。 现在，在Java中，当调用者将原语传递给被调用方法时，被调用方法只是将其克隆为新的局部变量，这是一个深层副本。 而如果传递一个对象，被调用的方法只会对同一对象进行新的本地引用，这是浅复制。 如果您了解调用，您就了解深/浅复制，& 反之亦然。

Answer 7

这似乎是文档中的一个错误。 我不明白 Android 的 Calendar.clone 方法所做的任何事情如何满足“浅拷贝”的典型定义（在 Java 或其他中）。

Answer 8

1.6 文档将 Calendar.clone 描述为“创建并返回此对象的副本”。 由 Object.clone 指定的文字浅拷贝没有任何意义。 Java 在相当典型的意义上使用术语“浅拷贝”。

Answer 9

浅拷贝是对象引用指针的拷贝，而深拷贝是对象本身的拷贝。 在Java中，对象保存在后台，处理对象时通常交互的是指针。 变量名指向对象的内存空间。 当您将一个变量设置为等于另一个变量时，就会创建浅复制，如下所示：

Object B = A;

可以通过获取对象 A 的属性并将它们放入新对象 B 中来创建深复制。

Object B = new Object(A.getProperty1(), A.getProperty2()...);

这会影响程序行为，因为如果您创建浅复制并对其执行一项任务，该任务会影响该对象的所有浅副本。 如果您对深层副本进行更改，则只有该副本受到影响。 我希望这对您来说足够详细。

Answer 10

浅拷贝只是一组指向相同内存位置的指针。 实际上它不会创建真正的副本，因此内存使用量较低。

在深度复制的情况下，会创建内存段的精确副本，并将指针设置为新的内存位置。 因此理论上，这种情况下的内存消耗应该是两倍。

Answer 11

浅拷贝只是复制类中引用的值。 深拷贝复制值。 给定：

class Foo {
  private Bar myBar;
  ...
  public Foo shallowCopy() {
    Foo newFoo = new Foo();
    newFoo.myBar = myBar;
    return newFoo;
  }

  public Foo deepCopy() {
    Foo newFoo = new Foo();
    newFoo.myBar = myBar.clone(); //or new Bar(myBar) or myBar.deepCopy or ...
    return newFoo;
  }
}

Foo myFoo = new Foo();  
Foo sFoo = myFoo.shallowCopy();  
Foo dFoo = myFoo.deepCopy();  

myFoo.myBar == sFoo.myBar => true  
myFoo.myBar.equals(sFoo.myBar) => true  
myFoo.myBar == dFoo.myBar => **false**  
myFoo.myBar.equals(dFoo.myBar) => true  

在这种情况下，浅复制具有相同的引用（==），而深复制仅具有等效引用（.equals()）。

如果对浅复制引用的值进行更改，则副本会反映该更改，因为它共享相同的引用。 如果对深度复制引用的值进行更改，则副本不会反映该更改，因为它不共享相同的引用。

C主义

int a = 10; //init
int& b = a; //shallow - copies REFERENCE
int c = a;  //deep - copies VALUE
++a;

结果：

a is 11  
*b is 11  
c is 10