在java方法中，如何通过值（而不是引用）传递由列表组成的列表？

我了解了如何通过其值传递ArrayList，以便调用的方法不会修改原始ArrayList。但是，我试图传递一个本身包含其他ArrayList的ArrayList；这是Arraylist中的Arraylist

public class Test {
public static void main(String[] args){
     ArrayList<ArrayList<Integer>> lists = new ArrayList<ArrayList<Integer>>();

     for(int j=0;j<2;j++){           
         ArrayList<Integer> list=new ArrayList<Integer>();           
         for(int i=5;i>0;i--){
             list.add(i);
         }
         lists.add(list);
     }

     System.out.println("Before");
     printLists(lists);

     processLists(lists);

     System.out.println("\nAfter");
     printLists(lists);     
}   
public static void processLists(ArrayList<ArrayList<Integer>> list){

    ArrayList<ArrayList<Integer>> myTrace=new ArrayList<ArrayList<Integer>>(list);
    //myTrace.addAll(list);     
    for(int j=0;j<myTrace.size();j++){ 
        myTrace.get(j).remove(myTrace.get(j).size()-1); //remove last element in the inner lists
    }       
    System.out.println("\nInside");     
    printLists(myTrace);
}

public static void printLists(ArrayList<ArrayList<Integer>> lists){     
    for(int i=0;i<lists.size();i++){
        for(int j=0;j<lists.get(i).size();j++){
            System.out.print(lists.get(i).get(j)+" ");
        }
        System.out.println();
    }
}   
}

公共类测试{
公共静态void main（字符串[]args）{
ArrayList list=新的ArrayList（）；
对于（int j=0；j0；i--）{
列表.添加（i）；
}
列表。添加（列表）；
}
系统输出打印项次（“之前”）；
打印列表（列表）；
进程列表（列表）；
System.out.println（“\n之后”）；
打印列表（列表）；
}   
公共静态void进程列表（ArrayList列表）{
ArrayList myTrace=新的ArrayList（列表）；
//myTrace.addAll（列表）；
对于（int j=0；j你链接到的文章说制作并传递列表的副本，这样就不能更改原始列表。同样的技术也可以在这里应用，但你必须复制所有内容。
当你说

ArrayList<T> a = new ArrayList<T> (b);

仅创建一个新的
ArrayList
。它不会复制所有
ArrayList
元素。因此，在上述操作之后，
myTrace.get（0）=list.get（0）
将为
true
，因为它们是相同的引用[如果列表不是空的话]。如果您执行了修改元素的操作，则修改将显示在以下两种情况中：

myTrace.get(n).set(x,y)

还将影响
list.get（n）
引用的
ArrayList
，因为
myTrace.get（n）
和
list.get（n）
将返回相同的引用

您需要一个循环来复制阵列：

ArrayList<ArrayList<Integer>> myTrace = new ArrayList<ArrayList<Integer>>();
for (ArrayList<Integer> sublist : list) {
    myTrace.add(new ArrayList<Integer>(sublist));  // makes a copy of the sublist
}

ArrayList myTrace=new ArrayList（）；
for（ArrayList子列表：列表）{
myTrace.add（newarraylist（sublist））；//制作子列表的副本
}

或者使用Java 8中的流：

ArrayList<ArrayList<Integer>> myTrace = new ArrayList<> (
    list.stream().map(ArrayList::new).collect(Collectors.toList()));

ArrayList myTrace=新建ArrayList(
list.stream（）.map（ArrayList:：new）.collect（Collectors.toList（））；
不要混淆引用传递和对象易变性。感谢您的建议。ArrayList myTrace=新建ArrayList（列表）；它不是在复制所有内容吗？myTrace.addAll（列表）；也没有帮助。什么没有被复制？@TanzeemBinNoor
ArrayList
的元素是对其他
ArrayList
的引用。当您使用该构造函数时，它将创建一个新的
ArrayList
，但内容将与原始列表相同。如果您需要所有这些列表的副本，您将拥有您可以在循环中或使用Java8流自行完成。这就是您想要的吗？
ArrayList<ArrayList<Integer>> myTrace = new ArrayList<> (
    list.stream().map(ArrayList::new).collect(Collectors.toList()));