相关疑难解决方法(0)

我一直认为Java是传递引用的.

但是,我看过一些博客文章(例如,这个博客)声称它不是.

我不认为我理解他们所做的区别.

解释是什么？

深拷贝和浅拷贝之间有什么区别？

可能重复:
Java是"传递引用"吗？

我今天发现了一种不寻常的Java方法:

private void addShortenedName(ArrayList<String> voiceSetList, String vsName)
{
     if (null == vsName)
       vsName = "";
     else
       vsName = vsName.trim();
     String shortenedVoiceSetName = vsName.substring(0, Math.min(8, vsName.length()));
     //SCR10638 - Prevent export of empty rows.
     if (shortenedVoiceSetName.length() > 0)
     {
       if (!voiceSetList.contains("#" + shortenedVoiceSetName))
         voiceSetList.add("#" + shortenedVoiceSetName);
     }
}

根据我读过的有关Java传递变量,复杂对象的行为的一切,这段代码应该什么都不做.所以嗯......我在这里错过了一些东西吗？是否有一些微妙的东西丢失在我身上,或者这些代码是否属于thedailywtf？

int[][] array = new int[][] {...}
int[][] clone = array.clone();

我天真地期待这个工作.但它没有 - 它只克隆了第一个维度,如果我想要一个真正的克隆,我必须手动克隆另一个维度.注意:内容已正确复制.但是,当我改变时clone[0][1],它反映在array[0][1]

虽然.clone()已知执行浅层克隆,但int[][]看起来像一个对象(如果我们不知道它的内部实现,至少)

为什么选择这种行为？是不是int[][]引用数组对象,而不仅仅是数组的第一个维度？在什么情况下只克隆第一个维度所需的行为？

是clone()Java中的浅拷贝？

最终,这将获得Object的clone()方法(最上层的类),它创建与对象相同的类的新实例,并将所有字段复制到新实例("浅拷贝").

我是从维基百科读到的.

我不明白为什么它是浅拷贝.clone()将创建一个包含所有字段的新实例.这只是一个很深的副本吗？困惑.需要一些解释.

我目前正在研究Java的图形库.如你所料,有一个Vertex班级.该类包含一个类型的对象,VertexData<T>它本身可以包含任何东西.
(我知道这可能是多余的,我可以这样做,Vertex<T>但为了问题的目的,这无关紧要).
我制作了一个VertexData<T>实现,Cloneable并有一个public VertexData<T> clone() 方法通过序列化和反序列化调用返回深层副本,Object就像这里描述的那样

现在问题是,因为我确实有一个深度复制方法,所以有一个浅拷贝是否有意义？如果是这样的话,那么浅拷贝比深拷贝更受欢迎的情况是什么？

更新:由于大多数答案和评论都包含对浅层副本的某种解释,我觉得我必须澄清一点.我知道浅色副本是什么,它是如何工作的,一切.我的问题是,因为它是我正在开发的库,并且因为我确实创建了一个深度复制方法,所以为浅层复制提供方法是否有意义？

我也在这里添加,VertexData<T>类中没有原始类型.
因此,在用于存储图库的 Vertex数据的容器类的上下文中,是否需要浅层复制？
如果是这样,你能想到一个例子,在我正在开发的范围内吗？
如果不是我应该只为了完整性添加浅拷贝方法？
这是一个好习惯还是没关系？

我有一堂课(文学).我需要能够在整个应用程序中将完整的Literal实例保存在内存中,并且有一份我可以更改的副本.我用两种方法来做到这一点:

1. class Literalimplements Cloneable和override Object.clone()方法.

2. 工厂构造:

   public Literal(Literal lit){
        this = lit;
   }
   

   Run Code Online (Sandbox Code Playgroud)

在这两种情况下,复制都不起作用.我对副本所做的每一项更改都会更改原件.有谁知道我做错了什么？

我试图克隆一个对象并更改新克隆对象的成员函数。如果是浅拷贝，并且根据wiki页面，浅拷贝和原始对象指向同一个对象，则应该更改变量值。

    CloneExample obj1=new CloneExample();
    CloneExample obj2=(CloneExample) obj1.clone();
    obj1.a=2;
    obj1.c='a';
    System.out.println("obj1 real "+obj1.a+" "+obj1.c);
    System.out.println("obj2 real "+obj2.a+" "+obj2.c);
    obj2.a=99;
    obj2.c='z';
    System.out.println("obj2 after change "+obj2.a+" "+obj2.c);
    System.out.println("obj1 after change "+obj1.a+" "+obj1.c);
    System.out.println("obj1="+obj1+" obj2="+obj2);

如果这个克隆是浅拷贝，那么 obj2 和 Obj1 指向同一个引用 obj，改变 obj2 应该反映在 obj1 中。它不会发生。任何人都可以解释一下（我知道克隆旨在为我们提供对象的副本，但如果是浅复制，那么为什么我们需要浅复制？我们应该始终进行深复制）。谢谢你。

List<List<Integer>> result = new ArrayList<List<Integer>>();
ArrayList<Integer> temp = new ArrayList<Integer>();
temp.add(5);temp.add(6);
result.add(temp);
temp.clear();

我编写了类似上面的代码,让我感到困惑的是当我调试代码时,我发现结果包含大小为1,但是在应用clear函数后,值(5,6,...)丢失了,任何一个都可以解释为什么？

我正在按升序和降序对数组进行排序。我做了两种方法，从main调用了它们。这些方法可以单独很好地工作，但是当我同时调用它们时，似乎最后一个覆盖了第一个的值。我知道应该很容易，但是我不知道发生了什么。有人可以向我解释吗？

import java.lang.reflect.Array;

public class Test {

    public static void main(String[] args) {
        int[] mayor, menor;
        int[] array1 = new int[] {5,3,10,8,27,4,1 }; 

        mayor= ordenMayor(array1);
        menor= ordenMenor(array1);

        for(int i=0; i<mayor.length ;i++) {
            System.out.print(" "+mayor[i]+" ");
        }

        System.out.println("");
        for(int i=0; i<menor.length ;i++) {
            System.out.print(" "+menor[i]+" ");
        }

        System.out.println("");
        for(int i=0; i<array1.length ;i++) {
            System.out.print(" "+array1[i]+" ");
        }


    }


    public static int[] ordenMayor(int[] arrayM) {
        int[] arrayMayor=arrayM;
        int mayor;
        int index;

        for(int i=0; i<arrayMayor.length - 1;i++) {
        mayor=arrayMayor[i];
        index=i;
            for(int j=i; j<arrayMayor.length …

下面是用javadocs编写的

类Object的equals方法实现了对象上最具辨别力的等价关系; 也就是说,对于任何非空引用值x和y,当且仅当x和y引用同一对象时,此方法才返回true(x == y的值为true).

是否表示object1.equals(object2)仅在object1 == object2时返回true.

下面的例子在In Java中,什么是浅拷贝？

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 …