将对象添加到 ArrayList 并在以后修改它

will this change reflect in the ArrayList?

Yes, since you added a reference to the object in the list. The reference you added will still point to the same object, (which you modified).

or when I add the object to the ArrayList, Java creates a copy and add it to the ArrayList?

No, it won't copy the object. (It will copy the reference to the object.)

What if I change the reference to this object to null? Does that mean that the object in the ArrayList now null too?

No, since the content of the original reference was copied when added to the list. (Keep in mind that it is the reference that is copied, not the object.)

Demonstration:

StringBuffer sb = new StringBuffer("foo");


List<StringBuffer> list = new ArrayList<StringBuffer>();
list.add(sb);


System.out.println(list);   // prints [foo]
sb.append("bar");


System.out.println(list);   // prints [foobar]


sb = null;


System.out.println(list);   // still prints [foobar]

Any change to the object will be reflected in the list.

However, when you deal with objects like Strings that are immutable, a new object will be created on "change operations". Than actually your old object is still in the list while you got a new one elsewhere.

Wanted to add another demonstration where the ArrayList is inside of a Map as the value. The ArrayList is modified after adding to the Map and the Map reflects the changes.

The Map has one element with mother's name as the key and children as the value.

    String key = "adeleMom";
Map<String, ArrayList<String>> myMap = new HashMap<String, ArrayList<String>>();
ArrayList<String> firstList = new ArrayList<String>();
firstList.add("adele");
myMap.put(key, firstList);
firstList = null;
ArrayList secondList = myMap.get(key);
System.out.println(secondList); // prints [adele]
secondList.add("bonnie");
System.out.println("Added bonnie");
ArrayList thirdList = myMap.get(key);
System.out.println(thirdList); // prints [adele, bonnie]

Thank you all guys. I figured it out again by reading your posts. It is probably a confusing concept, since I've had it digested long ago but recently I forgot how it works again. So I wanna share the tip that solves the problem for me. Note that non-primitive objects (primitives are int, boolean, etc) in java are technically pointers. When you add the 'Object o' to a list, the list's item and the 'o' point to the same thing. So when you modify 'o' (you're changing something that both 'o' & list's item are pointing to) the list's item changes too. This is as long as they point to the same thing. So this rule does not apply when 'o' points to something else after using '=' on it.

o = null;   //'o' points to nothing and from now on, changes in 'o' doesn't effect the list's item

or

Object a = new Object();
o = a;    //'o' and the list's item don't point to same thing so changes in 'o' doesn't effect the list's item (but it effects 'a')

hope it helps someone