Deep copy of a list with custom objects in java

Question

I have a List with custom objects. I want to create a deep copy of that List. Here is the class of the custom Object:

public class MyMemo {
    private List<Uri> imageUriList;
    private String commentText;

    public MyMemo(){
        imageUriList = new ArrayList<>();
    }

    public List<Uri> getImageUriList() {
        return imageUriList;
    }

    public void setImageUriList(List<Uri> imageUriList) {
        this.imageUriList = imageUriList;
    }

    public String getCommentText() {
        return commentText;
    }

    public void setCommentText(String commentText) {
        this.commentText = commentText;
    }
}

Now I have below situation:

List<MyMemo> parentList = new ArrayList<>();
List<MyMemo> copyList = new ArrayList<>(parentList);
parentList.get(currentMemoPosition).getImageUriList().removeAll(someOtherList.getImageUriList());
Log.e(TAG,"Total List: "+parentList.get(currentMemoPosition).getImageUriList().size()+" "+copyList.get(currentMemoPosition).getImageUriList().size());

But if I make any change to the parentList i.e either delete an item from it or add new item to it. copyList is also effected. How can I make sure copyList is not referring the same memory address.

Update:

As suggested to use clone(). But problem is I have a list in my custom object. How can I clone() them?

create a `clone` method that will copy each and every element of the *source* into the *destination* which shall be the returned value. somewhat like *Prototype* design pattern. — Wreigh, Feb 02 '18 at 03:59
Can you give an example `main()` method that shows the problems you have encountered? — Code-Apprentice, Feb 02 '18 at 03:59
@Code-Apprentice updated my code. I used `removeAll()` to alter the inner list of the custom object of `parentList`. But that is also effecting the `copyList` size as well. — sagar suri, Feb 02 '18 at 04:05
Possible duplicate of [How to make a deep copy of Java ArrayList](https://stackoverflow.com/questions/7042182/how-to-make-a-deep-copy-of-java-arraylist) — Ravi, Feb 02 '18 at 04:06
@Ravi I have a list inside each custom object. How to clone them ? — sagar suri, Feb 02 '18 at 04:07
@Wreigh I have a list inside each custom object. How to clone them ? — sagar suri, Feb 02 '18 at 04:07
@XoXo your custom object will have to define its own copy method. You'll need to write it yourself. There is no generic "deep copy." — Louis Wasserman, Feb 02 '18 at 04:11

Matt · Answer 1 · 2018-02-05T23:41:45.663

When you create your first list:

List<MyMemo> parentList = new ArrayList<>();
parentList.add(customObject1);
parentList.add(customObject2);
parentList.add(customObject3);

parentList is a list of references to the custom objects.

When you copy the contents of parentList into copyList:

List<MyMemo> copyList = new ArrayList<>(parentList);

copyList now contains references to the same objects as parentList. If you change an object in parentList the object is also changed in copyList because they are the same object.

To create a deep copy of the list you need a way to copy one of your custom objects. You could implement a copy constructor or a clone method:

class CustomObject {
    private String item1;
    private String item2;

    public CustomObject(String item1, String item2) {
        this.item1 = item1;
        this.item2 = item2;
    }

    // copy constructor
    public CustomObject(CustomObject other) {
        this.item1 = other.getItem1();
        this.item2 = other.getItem2();
    }

    // clone
    public CustomObject clone() {
        CustomObject newObj = new CustomObject(this.getItem1(), this.getItem2());
        return newObj;
    }
}

Then you can copy an object like this:

CustomObject newObj = new CustomObject(existingObj);

or like this:

CustomObject newObj = existingObj.clone();

Now you can make a deep copy of your list using the copy constructor:

List<CustomObject> copyList = new ArrayList<>();
for(CustomObject obj : parentList) {
    copyList.add(new CustomObject(obj));
}

or the clone method:

List<CustomObject> copyList = new ArrayList<>();
for(CustomObject obj : parentList) {
    copyList.add(obj.clone());
}

I prefer to use a copy constructor. You can read a good article by Josh Block in Effective Java on the use of clone vs copy constructor.

@Matt Lii mentions that Java 8 provides a new way to call the copy constructor using streams, lamdas and collectors here: https://stackoverflow.com/a/33507565/3796660. Any thoughts on this versus your copy constructor approach? — AJW, Aug 04 '23 at 04:05
@AJW I like the streams approach but I haven't used Java in quite some time now. — Matt, Aug 18 '23 at 12:26
@Matt Do you use Kotlin now rather than Java, or you haven't used either recently? — AJW, Aug 18 '23 at 13:36
I've been working with Go for the last few years, things changed at work :) — Matt, Aug 20 '23 at 07:22

score 6 · Accepted Answer · edited May 03 '19 at 13:17

6

IMO, add another arg constructor, which will do deep cloning for your Object.

public class MyMemo {
    MyMemo(MyMemo memo)
    {
       this.commentText = memo.getCommentText();
       this.imageUriList = new ArrayList<>();
       for (Uri uri : memo. getImageUriList())
       {
           this.imageUriList.add(new Uri(uri));
       }
    }
    // rest of your code
}

Now, iterate your parent List and clone each object

List<MyMemo> parentList = new ArrayList<>();
List<MyMemo> copyList = new ArrayList<>();
for (MyMemo memo : parentList)
{
   // create new instance of MyMemo and add to the list
   copyList.add(new MyMemo(memo));
}

edited May 03 '19 at 13:17

Daniele

668
2
10
25

answered Feb 02 '18 at 04:16

Ravi

30,829
42
119
173

Worked like charm :) – sagar suri Feb 02 '18 at 04:52
@Ravi Lii mentions that Java 8 provides a new way to call the copy constructor using streams, lamdas and collectors here: stackoverflow.com/a/33507565/3796660. Any thoughts on this versus your copy constructor approach? – AJW Aug 04 '23 at 04:06

score 0 · Answer 3 · answered Feb 02 '18 at 04:46

all options below will make a shallow copy which means that changing a value in one array will affect the second one .It's no thread safe

1.

         List<Sth> a = new ArrayList<>();
         List<Sth> b = new ArrayList<>(a);

2.

        `Collection.copy(a,b)`

3.

ArrayList<Sth> b= (ArrayList) a.clone();

to create a new copy if a list you should iterate over this list and add elements to another list. this is a deep copy.

score 0 · Answer 4 · answered Feb 02 '18 at 05:03

You can also create new list, create new object and use BeanUtils to copy properties,

for (MyMemo current : parentList) {
    MyMemo copyCurrent = new Data();
    BeanUtils.copyProperties(copyCurrent, current);
    copyList.add(copyCurrent);
}

This will give a deep copy of objects in the list.

score 0 · Answer 5 · edited May 05 '20 at 15:40

In Android, if you try to make deep copy object type ArrayList then you able to copy them but when an object in 1st list made any changes then those changes reflected in the second list also.

for that, there is one solution,

create one class with list property
convert that class object to String using Gson().toJson()
when you want that copied list again convert that String to the Class object.

 public class MyMemo {
     private List<DemoClass> demoList;
 }

 MyMemo m = new Mymemo();
 m.demoList(..,..,)

 1. String s = Gson().toJson(m)
 2.Mymemo m = Gson().fromJson(s,Mymemo.java)

Deep copy of a list with custom objects in java

5 Answers5

Linked