Return to Revisions

This is what you have now

ArrayList<ArrayList<Integer>> outer = new ArrayList<ArrayList<Integer>>();
ArrayList<Integer> inner = new ArrayList<Integer>(); 

will create

outer -> []
inner -> []

After

inner.add(100); 
inner.add(200);

your situation looks like

outer -> []
inner -> [100, 200]

Here comes confusing part

outer.add(inner);
outer.add(inner);

which in fact copy value of inner reference which means they hold same list as one from inner

outer -> [ reference1 , reference2 ]
 | |
 +-------+ |
 +---------------------+
 ↓
inner -> [100, 200]

which means that if you change state of list held by inner you will be able to see these changes using reference1 and reference2. Same if you change this list via other references, so when you use

outer.get(0).add(300);

get(0) returns list which you can access also via inner or get(1) and adding new element so now situation looks like

outer -> [ reference1 , reference2 ]
 | |
 +-------+ |
 +---------------------+
 ↓
inner -> [100, 200, 300]

That is why when you print outer you are seeing

[[100, 200, 300], [100, 200, 300]]. 
 ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
 from get(0) from get(2)

What you actually need is to create separate list so reference1 and reference2 will point to two separate lists. So you need something like

outer -> []
inner1 -> [100, 200]
inner2 -> [100, 200]

which will be later organized to

outer -> [ reference1 , reference2 ]
 | |
 +------+ |
 ↓ |
inner1 -> [100, 200] |
 |
 +--------------------+
 ↓
inner2 -> [100, 200]

You can do it this way

List<List<Integer>> outer = new ArrayList<List<Integer>>();
List<Integer> inner1 = new ArrayList<Integer>();
List<Integer> inner2 = new ArrayList<Integer>();
inner1.add(100);
inner1.add(200);
inner2.add(100);
inner2.add(200);
outer.add(inner1);
outer.add(inner2);
outer.get(0).add(300);
System.out.println(outer);