copy constructor with ArrayList parameter

Question

I'm trying to make a copy constructor for an object and one of the parameters is an ArrayList.

when creating the ArrayList object, I had in mind to use the ArrayList constructor where you can pass a collection as a parameter, but I'm not sure if this will work as a "pointer" to the arraylist or if this will create a whole new arraylist object

This is the code I have

public MyObject(MyObject other)
{
    this.brands= other.brands;
    this.count = other.count;
    this.list = new ArrayList<Integer>(other.list); // will this create a new array list with no pointers to other.list's elements?

}

Answer 1

I'm not sure if this will work as a "pointer" to the arraylist or if this will create a whole new arraylist object

When you use new, it will create a brand spanking new instance of ArrayList (this is what you have asked). But it will not also automatically create copies of its elements (which I think is what you are looking for). What this means is, if you change a mutable object in the new List, it will also change in the original List, if it is still around. This is because the List only holds references (kinda sorta but not exactly pointers) to the Objects in them, not the actual Objects themselves.

For example:

Person person = new Person("Rob"); // create a new Object

List<Person> myList = new ArrayList<Person>();
myList.add(person);

// Create another list accepting the first one
List<Person> myList2 = new ArrayList<Person>(myList);

for(Person p : myList2) {
    p.setName("John"); // Update mutable object in myList2
}

person = new Person("Mary"); // stick another object into myList2
myList2.add(person);

for(Person p : myList2) {
    System.out.println(p.getName()); // prints John and Mary as expected
}

for(Person p : myList) {
    System.out.println(p.getName()); // prints only one result, John.
}

So you can see that the two Lists themselves can be modified independently, but when you use the constructor accepting another List, both will contain references to the same Person instances, and when the state of these objects change in one List, they will also change in the other (kinda sorta just like pointers).