将LinkedList添加到包含LinkedList的LinkedList中，并更改添加的LinkedList

Question

I want to add a LinkedList<Integer> (let's call it list A) to a LinkedList<LinkedList<Integer>> (call it list B). After doing so I need to change the values of list A and add it to list B again, but without changing the values already stored in List B.

I need this to store a unknown number of paths in a LinkedList containing LinkedLists. The number of LinkedList's that are supposed to be added to List B are always different and I cannot just work with a LinkedList<Integer> C that copies A. In most cases I'm probably going to need a lot of list's in list B.

public static void main(String[] args) 
{
    LinkedList<LinkedList<Integer>> B = new LinkedList<LinkedList<Integer>>();
    LinkedList<Integer> A = new LinkedList<Integer>();

    // just adding some numbers to List A
    A.add(1);
    A.add(2);
    A.add(3);

    // adding list A to list B
    B.add(A);

    // adding another number to list A
    A.add(4);

    // this will print out [[1,2,3,4]] now
    // I want it to print out [[1,2,3]], even though I changed List A
    System.out.println(B);
}

Current result:

[[1, 2, 3, 4]];

Expected result:

[[1,2,3]]

Answer 1

You can do something like this,

 A = new LinkedList<Integer>();
 A.add(4);

The code why it's behaving like that is You are adding the reference of linkedlist a to b so whatever changes you made to a will reflect in the b.

Answer 2

The below code will copy all contents of the previous list stored into B, Via Collections.copy, and leave you free to change the contents of List A without affecting the values of the lists stored in B.

public static void main(String[] args) {
    LinkedList<LinkedList<Integer>> B = new LinkedList<LinkedList<Integer>>();
    for (int i = 0; i < listsGiven.size(); i++) {
        LinkedList<Integer> A = listsGiven.get(i);
        successiveCopy(B, A, i);
    }
}

static void successiveCopy(LinkedList<LinkedList<Integer>> B, LinkedList<Integer> A, int index) {
    if (B.size() == 0) { 
        B.add(A); return; 
    }
    B.add(Collections.copy(A, B.get(index - 1));
}

Answer 3

Personally, I would copy when adding to the outer list.

B.add(new LinkedList<>(A));

This way the copying is coupled with the reason that the copying is needed: you want to store the current state of the list. You can then safely modify the original list.