0

i am copying object tt to ttt and i want to make change to ttt only but when i update ttt dunno why it update my tt along???? it's my makechange() function got problem?

this is main class:

package test;

public class Test {

public static void main(String[] args) {
    Solution sol;
    sol= new Solution();

    sol.add();
    sol.copy();
    //this makechange function only update ttt only!!
    sol.makechange();
    sol.disOld();
    System.out.println("===============");
    sol.disNew();

}
}

this is new class: 

package test;

import java.util.ArrayList;
import java.util.List;

public class Solution {
Object[][] tt=new Object[2][2];
Object[][] ttt=new Object[2][2];
List l = new ArrayList<>();

public void add(){
    l.add(100);
    tt[0][0]=l;
    l = new ArrayList<>();
    l.add(123);
    tt[0][1]=l;
    l = new ArrayList<>();
}

public void disOld(){
    for(int i=0; i<tt.length; i++){
        for(int j=0; j<tt[i].length; j++){
            System.out.println(tt[i][j]);
        }
    }
}

public void copy(){
    ttt=tt;
}

public void makechange(){
    l.add(99);
    ttt[1][0]=l;
}

public void disNew(){
    for(int i=0; i<ttt.length; i++){
        for(int j=0; j<ttt[i].length; j++){
            System.out.println(ttt[i][j]);
        }
    }
}

}

this is my output:

[100]
[123]
[99]
null
===============
[100]
[123]
[99]
null

this is my expected output should be like this:

[100]
[123]
null
null
===============
[100]
[123]
[99]
null
hellohai
  • 1
  • 2

3 Answers3

4

Because = just copies the reference (pointer), not the object, so the real object you're referencing is the same. I suggest you use a copy constructor as explained here.

You can read a more extended explanation here (it's about ArrayList, but you can extrapolate to any other object).

Extract from that answer:

b = a

Keep in mind this lines DOES NOT copy the whole list a to b, but only copies the reference to the list. Now both a and b reference (point) to the same List. So it doesn't matter if you use a.add() or b.add(), you'll be modifying the same List.

To help you understand the above, check the following diagram

enter image description here

The left diagram corresponds to when you do Object[][] tt=new Object[2][2];. You can see that you create an Object[2][2] instance in memory, which is the circle, and you assign a pointer (reference) to it called tt, which is the rectangle.

The right diagram corresponds to when you do ttt = tt. This means: "make ttt point to same object as tt". It does not copy anything for you. So now both tt and ttt point (reference) the same object instance in memory. So if you use tt or ttt, you will be modifying the same object instance.

I hope this clarifies what you're doing. As for fixing it, you should copy each element of the array one by one as explained in Duncan's answer. More generically, you should use a copy constructor to copy objects as I linked above.

Community
  • 1
  • 1
m0skit0
  • 25,268
  • 11
  • 79
  • 127
  • @hellohai I've linked another answer of mine which is about the same subject. [Copying objects in Java is not as easy as you might think at first](http://stackoverflow.com/questions/869033/how-do-i-copy-an-object-in-java). – m0skit0 Dec 02 '14 at 15:34
  • Your answer is complicated and not related to object instead of lists – hellohai Dec 02 '14 at 15:41
  • Lists and arrays are objects, same applies. Answer is not complicated, you're simply confusing things. I'll update my answer with a diagram so you can understand better. – m0skit0 Dec 02 '14 at 15:42
  • @hellohai Updated, I hope this explains better why when you modify `tt` `ttt` is also modified. I cannot explain in a more simple way than this. – m0skit0 Dec 02 '14 at 15:55
  • @hellohai I see that you were looking for a copy-paste solution rather than an explanation. You will get this issue again if you don't understand this, but hey that's your problem, isn't it? ;) – m0skit0 Dec 02 '14 at 16:50
2

The = just makes both references point to the same object. If you want to make a copy(in general), then have a look at Cloninng(Not Recommended) in Java or consider a Copy-Constructor.

To solve your problem, change your copy method to the following:

public void copy(){
    for(int i=0; i<tt.length; i++)
        for(int j=0; j<tt[i].length; j++)
             ttt[i][j]= tt[i][j];
}
javaHunter
  • 1,097
  • 6
  • 9
1

This is not how you copy an array:

public void copy(){
    ttt=tt;  // booo, hisss, etc.
}

After this method executes, ttt points at exactly the same array as tt. Changes made to that array are visible through both variables.

You need to properly copy the array, e.g. using a technique from How do I copy a 2 Dimensional array in Java?.

Community
  • 1
  • 1
Duncan Jones
  • 67,400
  • 29
  • 193
  • 254