正文

Arrays.asList(array) 和 new ArrayList<Integer>(Arrays.asList(array)) 的区别

 2023-02-25  15

关键词：

【中文标题】Arrays.asList(array) 和 new ArrayList<Integer>(Arrays.asList(array)) 的区别【英文标题】：Difference between Arrays.asList(array) and new ArrayList<Integer>(Arrays.asList(array)) 【发布时间】：2013-05-20 19:49:21 【问题描述】：

有什么区别

List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia)); // Copy

List<Integer> list2 = Arrays.asList(ia);

，其中ia 是一个整数数组？

我了解到list2 中不允许某些操作。为什么会这样？它是如何存储在内存中的（引用/复制）？

当我打乱列表时，list1 不会影响原始数组，但list2 会。但是list2 还是有些混乱。

ArrayList 被向上转换到列表与创建新的ArrayList 有何不同？

list1 differs from (1)
ArrayList<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia));

【问题讨论】：

我建议你照顾Google Guava's选项。 Lists.newArrayList(ia) 制作独立副本，就像第一个选项一样。它只是更通用，更好看。 【参考方案1】：

首先，让我们看看这是做什么的：

Arrays.asList(ia)

它接受一个数组ia 并创建一个实现List<Integer> 的包装器，这使得原始数组可以作为一个列表使用。没有复制任何内容，只创建了一个包装器对象。列表包装器上的操作被传播到原始数组。这意味着如果你打乱列表包装器，原始数组也会被打乱，如果你覆盖一个元素，它会在原始数组中被覆盖，等等。当然，包装器上不允许一些List操作，就像在列表中添加或删除元素一样，您只能读取或覆盖元素。

请注意，列表包装器不会扩展 ArrayList - 它是一种不同的对象。 ArrayLists 有自己的内部数组，它们在其中存储元素，并且能够调整内部数组的大小等。包装器没有自己的内部数组，它仅将操作传播到给定的数组。

另一方面，如果您随后创建一个新数组为

new ArrayList<Integer>(Arrays.asList(ia))

然后您创建新的ArrayList，它是原始文件的完整、独立副本。尽管在这里您也使用Arrays.asList 创建了包装器，但它仅在构建新的ArrayList 期间使用，并且之后会被垃圾收集。这个新的ArrayList 的结构完全独立于原始数组。它包含相同的元素（原始数组和这个新的ArrayList 在内存中引用相同的整数），但它创建了一个新的内部数组来保存引用。所以当你打乱它，添加，删除元素等时，原来的数组是不变的。

【讨论】：

@Dineshkumar 包装器是一种将类的一个接口转换为另一个接口的设计模式。请参阅the wrapper pattern 文章。 |你需要在哪里上转？我建议将List<Integer> 用于您的变量类型（或方法参数等）。这使您的代码更加通用，您可以根据需要轻松切换到另一个 List 实现，而无需重写大量代码。这是一个很好的解释。扩展这个问题，Arrays.asList() 方法也需要可变参数。如果我传递特定值，比如说我这样做： Arrays.asList(1,3,5) 两次，它会返回相同的列表吗？【参考方案2】：

嗯，这是因为Arrays.asList() 产生的ArrayList 不是java.util.ArrayList 的类型。

Arrays.asList() 创建了一个java.util.Arrays$ArrayList 类型的ArrayList，它不扩展java.util.ArrayList，而只扩展java.util.AbstractList。

【讨论】：

我认为这是万恶之源。【参考方案3】：

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);

【讨论】：

【参考方案4】：

对于寻求答案的人来说，带有文档参考的解释会更好。

1。 java.util.Arrays

这是一个实用类，其中包含用于对给定数组进行操作的一堆静态方法 asList 就是这样一种静态方法，它接受输入数组并返回 java.util.Arrays.ArrayList 的对象，该对象是扩展 AbstractList 的静态嵌套类，而 AbstractList 又实现了 List 接口。所以 Arrays.asList(inarray) 在输入数组周围返回一个 List 包装器，但这个包装器是 java.util.Arrays.ArrayList 而不是 java.util.ArrayList，它指的是同一个数组，因此向 List 包装数组添加更多元素也会影响原始数组，而且我们无法更改长度。

2。 java.util.ArrayList

ArrayList 有一堆重载的构造函数

 public ArrayList() - // Returns arraylist with default capacity 10

 public ArrayList(Collection<? extends E> c)

 public ArrayList(int initialCapacity)

所以当我们将 Arrays.asList 返回的对象，即 List(AbstractList) 传递给上面的第二个构造函数时，它将创建一个新的动态数组（这个数组的大小会随着我们添加的元素超过其容量以及新的元素不会影响原始数组）浅拷贝原始数组（shallow copy 表示它仅复制引用，并且不会创建一组与原始数组相同的新对象）

【讨论】：

【参考方案5】：

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'。

如果您尝试在现有数组/列表中添加一个元素，那么您将得到“线程“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);

在上面的语句中，您创建了一个 ArrayList 类的具体实例并将一个列表作为参数传递。

在这种情况下，方法 add 和 remove 将正常工作，因为这两个方法都来自 ArrayList 类，所以这里我们不会得到任何 UnSupportedOperationException。在 Arraylist 对象中所做的更改（方法在 Arraylist 中添加或删除元素）将不会反映到原始 java.util.List 对象。

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

【讨论】：

【参考方案6】：

首先，Arrays 类是一个实用类，它包含许多用于操作 Arrays 的实用方法（感谢 Arrays 类。否则，我们需要创建自己的方法来操作 Array 对象）

asList() 方法：

asList

Array

Arrays.asList(T...a)

ArrayList

Array

asList

Array

List

不

List

Array

List

Array

list.add(10)

list.remove(10);

Array

在第一种情况下，您正在创建一个新的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));

案例2：

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));

【讨论】：

【参考方案7】：

请注意，在 Java 8 中，上面的 'ia' 必须是 Integer[] 而不是 int[]。 int 数组的 Arrays.asList() 返回具有单个元素的列表。使用 OP 的代码 sn-p 时，编译器会发现问题，但某些方法（例如，Collections.shuffle()）会默默地无法达到您的预期。

【讨论】：

我在执行 ArrayList al = new ArrayList(Arrays.asList(a)); 时遇到了这个编译器问题其中 a 是一个 int[]。我的人在打印时也只有一个元素，看起来很垃圾。那是什么元素？它是怎么发生的？我在 Java 7 中遇到了这个问题 @JyotsanaNandwani 请检查我的答案：***.com/a/54105519/1163607【参考方案8】：

很多人已经回答了机械细节，但值得注意的是：对于 Java，这是一个糟糕的设计选择。

Java 的asList 方法记录为“返回一个固定大小 列表...”。如果你获取它的结果并调用（比如说）.add 方法，它会抛出一个UnsupportedOperationException。这是不直观的行为！如果一个方法说它返回一个List，标准的期望是它返回一个支持接口List的方法的对象。开发人员不必记住哪些在众多util.List 方法中创建了实际上并不支持所有List 方法的List。

如果他们将方法命名为 asImmutableList，那将是有意义的。或者，如果他们只是让该方法返回一个实际的 List（并复制支持数组），那将是有意义的。他们决定同时支持运行时性能和短名称，代价是同时违反principle of least astonishment 和避免UnsupportedOperationExceptions 的良好面向对象实践。

（另外，设计者可能会创建一个interface ImmutableList，以避免过多的UnsupportedOperationExceptions。）

【讨论】：

【参考方案9】：

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());

【讨论】：

【参考方案10】：

Arrays.asList()

此方法返回它自己的 List 实现。它将数组作为参数并在其上构建方法和属性，因为它不是从数组中复制任何数据，而是使用原始数组，当您修改 Arrays.asList() 方法返回的列表时，这会导致原始数组发生变化。

另一方面，ArrayList(Arrays.asList()); 是ArrayList 类的构造函数，它接受一个列表作为参数并返回一个独立于列表的ArrayList，即Arrays.asList() 在这种情况下作为参数传递。

这就是您看到这些结果的原因。

【讨论】：

【参考方案11】：

1.List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia));  //copy
2.List<Integer> list2 = Arrays.asList(ia);

在第 2 行中，Arrays.asList(ia) 返回定义在Arrays 中的内部类对象的List 引用，该引用也称为ArrayList，但它是私有的并且仅扩展AbstractList。这意味着从 Arrays.asList(ia) 返回的对象与从 new ArrayList<Integer> 获得的对象不同。

您不能对第 2 行使用某些操作，因为 Arrays 中的内部私有类不提供这些方法。

看看这个链接，看看你可以用私有内部类做什么： http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/Arrays.java#Arrays.ArrayList

第 1 行创建了一个新的 ArrayList 对象，该对象复制了从第 2 行获得的元素。因此您可以做任何您想做的事情，因为 java.util.ArrayList 提供了所有这些方法。

【讨论】：

【参考方案12】：

针对一些 cmets 询问自 Java 8 以来Arrays.asList() 的行为的问题：

    int[] arr1 = 1,2,3;
    /* 
       Arrays are objects in Java, internally int[] will be represented by 
       an Integer Array object which when printed on console shall output
       a pattern such as 
       [I@address for 1-dim int array,
       [[I@address for 2-dim int array, 
       [[F@address for 2-dim float array etc. 
   */
    System.out.println(Arrays.asList(arr1)); 

    /* 
       The line below results in Compile time error as Arrays.asList(int[] array)
       returns List<int[]>. The returned list contains only one element 
       and that is the int[] 1,2,3 
    */
    // List<Integer> list1 = Arrays.asList(arr1);

    /* 
       Arrays.asList(arr1) is  Arrays$ArrayList object whose only element is int[] array
       so the line below prints [[I@...], where [I@... is the array object.
    */
    System.out.println(Arrays.asList(arr1)); 

    /* 
     This prints [I@..., the actual array object stored as single element 
     in the Arrays$ArrayList object. 
    */
    System.out.println(Arrays.asList(arr1).get(0));

    // prints the contents of array [1,2,3]
    System.out.println(Arrays.toString(Arrays.asList(arr1).get(0)));

    Integer[] arr2 = 1,2,3;
    /* 
     Arrays.asList(arr) is  Arrays$ArrayList object which is 
     a wrapper list object containing three elements 1,2,3.
     Technically, it is pointing to the original Integer[] array 
    */
    List<Integer> list2 = Arrays.asList(arr2);

    // prints the contents of list [1,2,3]
    System.out.println(list2);

【讨论】：

【参考方案13】：

差异总结-

当不使用 new 创建列表时，运算符 Arrays.asList() 方法返回一个 wrapper，这意味着：

您可以执行添加/更新操作。

在原始数组中所做的更改也将反映到 List 中，反之亦然。

【讨论】：

arrays.aslist()用法梳理(代码片段)

Arrays.asList()用法梳理asList概述Arrays是java容器相关操作的工具类，asList方法将Array转换为list，是Array和List之间的桥梁。asList本质使用工具类Arrays.asList()把数组转换成集合时，不能使用其修改集合相关的方法，它的add/remove/clear方法... 查看详情

数组的 Arrays.asList()

】数组的Arrays.asList()【英文标题】：Arrays.asList()ofanarray【发布时间】：2010-11-1722:31:39【问题描述】：这个转换有什么问题？publicintgetTheNumber(int[]factors)ArrayList<Integer>f=newArrayList(Arrays.asList(factors));Collections.sort(f);returnf.ge 查看详情

持有对象---arrays.aslist()和collections.addall()的性能比较

importjava.util.ArrayList; importjava.util.Arrays; importjava.util.Collections; importjava.util.List; publicclassArraysCompareCollectionsTest publicstaticvoidmain(String[]args) intcount=10000000;//通过改变循环次数来放大或放小结果 System.out.println(... 查看详情

Arrays.asList() 不能正常工作？

】Arrays.asList()不能正常工作？【英文标题】：Arrays.asList()notworkingasitshould?【发布时间】：2010-11-3020:59:24【问题描述】：我有一个float[]，我想获得一个包含相同元素的列表。我可以做一件丑陋的事情，将它们一一添加，但我想使... 查看详情

arrays.aslist使用误区(代码片段)

Arrays.asList使用的jar包是importjava.util.Arrays; Arrays.asList是使用该jar中的ArrayList方法 1、基本类型数组Int[]intArr=1,2,3;ListlistArr=Arrays.asList(int 查看详情

arrays.aslist的用法

使用工具类Arrays.asList()把数组转换成集合时，不能使用其修改集合相关的方法，它的add/remove/clear方法会抛出UnsupportOperationException异常说明：asList的返回对象是一个Arrays内部类,并没有实现集合的修改方法。Arrays.asList体现的是适配... 查看详情

arrays.aslist中所遇到的坑

...supportedOperationException异常从代码定位来看，原来是使用了Arrays.asList()方法时把一个数组转化成List列表时，对得到的List列表进行add()和remove()操作,所以导致了这个问题。对于这个问题，现在来总结下，当然会总结Arrays下面的... 查看详情

Arrays.asList（int []）不工作[重复]

】Arrays.asList（int[]）不工作[重复]【英文标题】：Arrays.asList(int[])notworking[duplicate]【发布时间】：2015-10-0323:58:55【问题描述】：当我运行以下代码时，没有输出任何输出。int[]array=3,2,5,4;if(Arrays.asList(array).contains(3))System.out.println("Th... 查看详情

java之arrays.aslist陷阱

Java.Util.Arrays可以将数组转换为List，具体的定义如下：@SafeVarargspublicstatic<T>List<T>asList(T...a){returnnewArrayList<>(a);}可以看到实际上是将这个数组转换成为了ArrayList<>，看似没有问题，但是当我们使用add和remove的时候... 查看详情

arrays.aslist方法遇到的问题

在使用Arrays.asList（T...a）方法时，遇到了java.lang.UnsupportedOperationException 异常。后来发现，该方法返回的类型是Arrays$ArrayList，即Arrays类的内部类ArrayList，而非集合中的ArrayList。Arrays$ArrayList继承了AbstractList但没有重写remove... 查看详情

c++ 中的类 Java Arrays.asList()

】c++中的类JavaArrays.asList()【英文标题】：Java-likeArrays.asList()inc++【发布时间】：2013-04-0818:03:51【问题描述】：C++是否支持STL或是否存在支持Arrays.asList()的外部库？典型用法privateArrayList<String>lexeme=newArrayList<String>(Arrays.asLi... 查看详情

arrays.aslist()返回一个特殊的“arraylist”

一个Arrays.asList()基本的用法：String[]str=newString[]{"1","2","3"};ArrayListal=newArrayList(Arrays.asList(str));//将数组元素添加到集合的一种快捷方式有时候这样使用就有可能出现问题：String[]str=newString[]{"1","2","3"};Listaslist=Arrays.asLis 查看详情

浅谈arrays.aslist()方法的使用

...add和remove方法　　上代码：1packagecom.hdu.test;23importjava.util.Arrays;4im 查看详情

java-一道关于arrays.aslist的题目(代码片段)

题目有这样一道有趣的题目：finalint[]test=newint[]1,2,3,4;finalInteger[]test2=newInteger[]1,2,3,4;finalListlist1=Arrays.asList(test);finalListlist2=Arrays.asList(test2);finalListlist3=Arrays.asList(1,2,3,4);Sys 查看详情

arrays.aslist（）vscollections.singletonlist（）(代码片段)

Collections.singletonList(something)是不可变的，对Collections.singletonList(something)返回的列表所做的任何更改将导致UnsupportedOperationException 。Arrays.asList(something)允许Arrays.asList(something) 更改。查看详情

arrays.aslist()(代码片段)

Arrays.asList()将一个数组转化为一个List对象，这个方法会返回一个ArrayList类型的对象。@SafeVarargs@SuppressWarnings("varargs")publicstatic<T>List<T>asList(T...a)returnnewArrayList<>(a);这个ArrayList类并非java.util.A 查看详情

从arrays.aslist到collection.toarray()(代码片段)

Arrays.asList()简介Arrays.asList()在平时开发中还是比较常见的，我们可以使用它将一个数组转换为一个List集合。String[]myArray="Apple","Banana","Orange";List<String>myList=Arrays.asList(myArray);//上面两个语句等价于... 查看详情