这两者有什么区别：
List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia)); // Copy
List<Integer> list2 = Arrays.asList(ia);
这里的 ia 是一个整数数组。
我了解到一些操作在 list2 中不被允许。为什么会这样？它在内存中是如何存储的（引用/复制）？
当我对这些列表进行洗牌时，list1 不会影响原始数组，但是 list2 会。但是对于 list2 我还是有点困惑。
将 ArrayList 向上转型成 List 和创建新的 ArrayList 之间有什么区别？
list1 differs from (1)
ArrayList<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia));
首先，让我们看看这个做了什么：
Arrays.asList(ia)
ia并创建一个包装器，实现List<Integer>，使原始数组可用作列表。没有复制任何内容，只创建了一个包装器对象。对列表包装器的操作会传播到原始数组。这意味着如果您打乱列表包装器，原始数组也会被打乱，如果您覆盖一个元素，它将在原始数组中被覆盖，等等。当然，一些List操作不允许在包装器上执行，例如往列表中添加或删除元素，您只能读取或覆盖元素。
请注意，列表包装器不扩展ArrayList——它是一种不同类型的对象。ArrayList具有自己的内部数组，其中存储它们的元素，并能够调整内部数组的大小等。该包装器没有自己的内部数组，它只将操作传播到给定的数组。
另一方面，如果随后创建一个新数组：
new ArrayList<Integer>(Arrays.asList(ia))
然后你创建一个新的ArrayList，它是原始ArrayList的完整独立副本。虽然在这里你也使用Arrays.asList创建了包装器，但它仅在构造新的ArrayList时使用，并在之后被垃圾回收掉。这个新ArrayList的结构与原始数组完全独立。它包含相同的元素（原始数组和这个新的ArrayList引用相同的整数内存），但它创建了一个新的内部数组来保存这些引用。因此当你洗牌、添加、删除元素等操作时，原始数组不会改变。
List<Integer> 作为您的变量类型（或方法参数等）。这可以使您的代码更加通用，您可以根据需要轻松切换到另一个 List 实现，而不必重写大量代码。 - PetrArrays.asList()创建的ArrayList不属于类型java.util.ArrayList。
Arrays.asList()创建了一个ArrayList，类型为java.util.Arrays$ArrayList，它并没有继承java.util.ArrayList，而只继承了java.util.AbstractList。List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia)); //copy
list1 的类型是 ArrayList。List<Integer> list2 = Arrays.asList(ia);
List视图返回，这意味着它只有与该接口相关的方法。 因此，一些方法在list2上不被允许。ArrayList<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia));
这里，你正在创建一个新的ArrayList。你只需在构造函数中传递一个值即可。这不是一个类型转换的示例。在类型转换中，它可能看起来更像这样：
ArrayList list1 = (ArrayList)Arrays.asList(ia);
asList 方法是Array类的实用程序方法之一，它是一个静态方法，因此我们可以通过其类名调用此方法（例如Arrays.asList(T...a)）。list.add(10)或list.remove(10);。否则它会抛出UnsupportedOperationException）。在第一种情况下，您正在创建一个新的ArrayList对象（在第二种情况下，仅创建对现有Array对象的引用，但不是新的ArrayList对象），因此现在有两个不同的对象。一个是Array对象，另一个是ArrayList对象，并且它们之间没有任何连接（因此，在一个对象中进行的更改不会反映/影响另一个对象（也就是说，在情况2中，Array和ArrayList是两个不同的对象）。
Integer [] ia = {1,2,3,4};
System.out.println("Array : "+Arrays.toString(ia));
List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia)); // new ArrayList object is created , no connection between existing Array Object
list1.add(5);
list1.add(6);
list1.remove(0);
list1.remove(0);
System.out.println("list1: " + list1);
System.out.println("Array: " + Arrays.toString(ia));
Integer [] ia = {1,2,3,4};
System.out.println("Array: " + Arrays.toString(ia));
List<Integer> list2 = Arrays.asList(ia); // Creates only a (new) List reference to the existing Array object (and NOT a new ArrayList Object)
// list2.add(5); // It will throw java.lang.UnsupportedOperationException - invalid operation (as Array size is fixed)
list2.set(0,10); // Making changes in the existing Array object using the List reference - valid
list2.set(1,11);
ia[2]=12; // Making changes in the existing Array object using the Array reference - valid
System.out.println("list2: " + list2);
System.out.println("Array: " + Arrays.toString(ia));
String names[] = new String[]{"Avinash","Amol","John","Peter"};
java.util.List<String> namesList = Arrays.asList(names);
或者
String names[] = new String[]{"Avinash","Amol","John","Peter"};
java.util.List<String> temp = Arrays.asList(names);
以上语句在输入数组上添加了包装器。因此，像add和remove这样的方法将无法应用于列表引用对象“namesList”。
如果您尝试向现有的数组/列表中添加元素，则会收到“Exception in thread "main" java.lang.UnsupportedOperationException”的错误。
以上操作是只读或视图操作。
我们不能在列表对象中执行添加或删除操作。
但是，
String names[] = new String[]{"Avinash","Amol","John","Peter"};
java.util.ArrayList<String> list1 = new ArrayList<>(Arrays.asList(names));
或者
String names[] = new String[]{"Avinash","Amol","John","Peter"};
java.util.List<String> listObject = Arrays.asList(names);
java.util.ArrayList<String> list1 = new ArrayList<>(listObject);
String names[] = new String[] {
"Avinash",
"Amol",
"John",
"Peter"
};
java.util.List < String > listObject = Arrays.asList(names);
java.util.ArrayList < String > list1 = new ArrayList < > (listObject);
for (String string: list1) {
System.out.print(" " + string);
}
list1.add("Alex"); // Added without any exception
list1.remove("Avinash"); // Added without any exception will not make any changes in original list in this case temp object.
for (String string: list1) {
System.out.print(" " + string);
}
String existingNames[] = new String[] {
"Avinash",
"Amol",
"John",
"Peter"
};
java.util.List < String > namesList = Arrays.asList(names);
namesList.add("Bob"); // UnsupportedOperationException occur
namesList.remove("Avinash"); // UnsupportedOperationException
对于寻找答案的人来说，一份附有文档引用的解释会更好。
ArrayList has a bunch of overloaded constructors
public ArrayList() - // Returns arraylist with default capacity 10
public ArrayList(Collection<? extends E> c)
public ArrayList(int initialCapacity)
So when we pass the Arrays.asList returned object, i.e., List(AbstractList) to the second constructor above, it will create a new dynamic array (this array size increases as we add more elements than its capacity and also the new elements will not affect the original array) shallow copying the original array (shallow copy means it copies over the references only and does not create a new set of same objects as in original array)
asImmutableList，那么这样做就有意义了。或者，如果他们只是让这个方法返回一个实际的List（并复制备份数组），那么这样做也有意义。他们决定在运行时性能和短名称之间取舍，以违反最小惊奇原则和避免UnsupportedOperationException等不良面向对象实践为代价。interface ImmutableList，以避免大量的UnsupportedOperationException。）package com.copy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
public class CopyArray {
public static void main(String[] args) {
List<Integer> list1, list2 = null;
Integer[] intarr = { 3, 4, 2, 1 };
list1 = new ArrayList<Integer>(Arrays.asList(intarr));
list1.add(30);
list2 = Arrays.asList(intarr);
// list2.add(40); Here, we can't modify the existing list,because it's a wrapper
System.out.println("List1");
Iterator<Integer> itr1 = list1.iterator();
while (itr1.hasNext()) {
System.out.println(itr1.next());
}
System.out.println("List2");
Iterator<Integer> itr2 = list2.iterator();
while (itr2.hasNext()) {
System.out.println(itr2.next());
}
}
}
Arrays.asList()
Arrays.asList()方法返回的列表时，会导致对原始数组的更改。ArrayList(Arrays.asList()); 是ArrayList类的一个构造函数，它以列表作为参数，并返回与列表无关的ArrayList，即在这种情况下传递为参数的Arrays.asList()。
Lists.newArrayList(ia)可以创建一个独立的副本，就像第一个选项一样。它只是更通用和更好看。 - qben