从数组创建ArrayList

Question

元素[]数组={新元素（1），新元素（2），新元（3）}；

如何转换上述类型的变量元素[]转换为类型为的变量ArrayList<元素>?

ArrayList<Element>ArrayList=。。。；

Answer 1

您可以使用以下说明：

new ArrayList<>（Arrays.asList（array））；

Answer 2

鉴于：

元素[]数组=新元素[]{新元素（1），新元素（2），新元（3）}；

最简单的答案是：

List<Element>List=Arrays.asList（array）；

这会很好。但有些警告：

1. 从asList返回的列表具有固定尺寸。因此，如果您希望能够在代码中添加或删除返回列表中的元素，则需要将其包装在一个新的数组列表。否则，您将获得不支持的操作异常.
2. 从返回的列表asList（）由原始数组支持。如果修改原始数组，列表也将被修改。这可能令人惊讶。

Answer 3

^{（老帖子，但只有2美分，因为没有提到Guava或其他libs和其他一些细节）}

如果可以，使用番石榴

值得指出的是，番石榴的方式大大简化了这些恶作剧：

用法

对于不可变列表

使用不可变列表类及其第页，共页（）和copyOf（）工厂方法^{（元素不能为空）}:

List<String>il=ImmutableList.of（“String”，“elements”）；//来自varargsList<String>il=ImmutableList.copyOf（aStringArray）；//来自阵列

对于可变列表

使用列表类及其newArrayList（）出厂方法：

List<String>l1=Lists.newArrayList（另一个ListOrCollection）；//来自集合List<String>l2=Lists.newArrayList（aStringArray）；//来自阵列List<String>l3=Lists.newArrayList（“or”，“String”，“elements”）；//来自varargs

请注意其他类中其他数据结构的类似方法，例如集合.

为什么是番石榴？

主要的吸引力可能是减少因使用番石榴属植物而导致的类型安全泛型带来的混乱工厂方法允许在大多数时间推断类型。然而，自从Java7带有新的菱形操作符以来，这种说法就不那么成立了。

但这并不是唯一的原因（Java7还没有普及）：速记语法也非常方便，如上所示，方法初始化器允许编写更具表现力的代码。在当前Java Collections中，只需一次Guava调用即可完成2。

---

如果你不能。。。

对于不可变列表

使用JDK阵列类及其asList（）工厂方法，用集合.不可修改列表（）:

List<String>l1=Collections.unmodifiableList（Arrays.asList（anArrayOfElements））；List<String>l2=Collections.unmodifiableList（Arrays.asList（“element1”，“element2”））；

请注意asList（）是一个列表使用混凝土数组列表实现，但它不是 java.util（实用程序）。数组列表。它是一个内部类型，它模拟数组列表但实际上直接引用传递的数组并使其“直写”（修改反映在数组中）。

它禁止通过某些列表通过简单扩展摘要列表（因此，不支持添加或删除元素），但它允许调用设置（）覆盖元素。因此，这个列表并不是真正不可变的asList（）应该用集合.unmodifiableList（）.

如果需要可变列表，请参阅下一步。

对于可变列表

同上，但用实际的java.util（实用程序）。数组列表:

列表<String>l1=new ArrayList<String>（Arrays.asList（array））；//Java 1.5到1.6List<String>l1b=new ArrayList<>（Arrays.asList（array））；//Java 1.7语言+列表<String>l2=new ArrayList<String>（Arrays.asList（“a”，“b”））；//Java 1.5至1.6列表<String>l2b=new ArrayList（Arrays.asList（“a”，“b”））；//Java 1.7+

---

出于教育目的：良好的手动方式

//适用于Java 1.5+static列表数组ToList（最终的T[]数组）{最终列表<T>l=新数组列表<T>（array.length）；for（最后的T：数组）{l.添加；}收益（l）；}//对于Java<1.5（没有泛型，没有编译时类型安全，嘘！）静态列表数组ToList（最终Object[]数组）{final List l=新的ArrayList（array.length）；for（int i=0；i<array.length；i++）{l.add（数组[i]）；}收益（l）；}

Answer 4

由于这个问题已经很古老了，我很惊讶还没有人提出最简单的形式：

List<Element>arraylist=Arrays.asList（新元素（1）、新元素（2）、新元（3））；

从Java 5开始，数组.asList（）采用varargs参数，不必显式构造数组。

Answer 5

新的ArrayList<T>（Arrays.asList（myArray））；

确保myArray（我的阵列）与类型相同T型。如果尝试创建列表＜Integer＞从数组整数例如。

Answer 6

Java 9语言

在Java 9语言，您可以使用第个列表，共个列表静态工厂方法，以便创建列表字面意义的。大致如下：

List<Element>elements=List.of（新元素（1）、新元素（2）、新元素（3））；

这将返回一个不可变的包含三个元素的列表。如果您想要可变的列表，将该列表传递给数组列表建造师：

new ArrayList（列表of（//元素vararg））

---

JEP 269：便利工厂收集方法

JEP 269号提供了一些方便的工厂方法Java系列应用程序编程接口。这些不可变的静态工厂方法内置于列表,设置、和地图Java 9及更高版本中的接口。

Answer 7

另一种方式（虽然本质上等同于new ArrayList（Arrays.asList（array））解决方案性能方面：

Collections.addAll（数组列表，数组）；

Answer 8

您可能只需要一个List，而不是ArrayList。在这种情况下，您可以执行以下操作：

List<Element>arraylist=Arrays.asList（array）；

Answer 9

另一个更新即将于2014年结束，您也可以使用Java 8实现：

ArrayList<Element>ArrayList=Stream.of（myArray）.colect（Collectors.toCollection（Array列表：：new））；

如果这只是一个列表

List<Element>List=Stream.of（myArray）.colect（Collectors.toList（））；

Answer 10

如果您使用：

new ArrayList＜T＞（Arrays.asList（myArray））；

你可以创造并填充两个列表！填写两次大列表正是你不想做的，因为它会创建另一个大列表对象[]每次需要扩展容量时都要进行阵列。

幸运的是，JDK实现速度很快，而且Arrays.asList（a[]）做得很好。它创建了一种名为Arrays的ArrayList。Object[]数据直接指向数组的ArrayList。

//阵列中@安全变量公共静态列表作为列表（T…a）{return new ArrayList（a）；}//仍在数组中，创建一个私有的不可见类私有静态类ArrayList私人决赛E【】a；ArrayList（E[]数组）{a=数组；//指向上一个数组}....}

危险的一面是如果更改初始数组，则更改List！你确定你想要吗？也许是，也许不是。

如果不是，最容易理解的方法是这样做：

ArrayList<Element>list=new ArrayList<Element>（myArray.length）；//你知道初始容量for（元素元素：myArray）{list.add（元素）；}

或者如@glglgl所述，您可以使用以下命令创建另一个独立的ArrayList：

新的ArrayList<T>（Arrays.asList（myArray））；

我喜欢使用收藏,阵列或番石榴。但如果它不合适，或者你感觉不到，就写另一行不雅观的。

Answer 11

在Java 9语言您可以使用：

List<String>List=List.of（“Hello”，“World”，“from”，“Java”）；List<Integer>List=（1，2，3，4，5）的列表；

Answer 12

根据这个问题，使用java 1.7的答案是：

ArrayList（数组）；

然而，最好始终使用界面：

列表<Element>arraylist=数组<元素>asList（数组）；

Answer 13

//番石榴导入com.google.common.collect。列表Lists...List<String>List=Lists.newArrayList（aStringArray）；

Answer 14

自从Java 8以来，有了一种更简单的转换方法：

导入java.util。列表；导入静态java.util.stream。收集器.toList；public static＜T＞List＜T＞from array（T[]数组）{return Arrays.stream（array）.collect（toList（））；}

Answer 15

您可以使用不同的方法进行转换

1. List<Element>List=Arrays.asList（array）；

2. List<Element>List=new ArrayList（）；
Collections.addAll（列表，数组）；

3. 数组列表=新数组列表（）；
list.addAll（Arrays.asList（array））；

有关更多详细信息，请参阅http://javareviewed.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

Answer 16

正如大家所说的那样

新的ArrayList（Arrays.asList（“1”、“2”、“3”、“4”））；

创建数组的最新常用方法是可观察阵列

可观察列表：允许侦听器在发生更改时跟踪更改的列表。

对于Java SE，您可以尝试

FXCollections.observableArrayList（新元素（1）、新元素（2）、新元（3））；

那是根据Oracle文档

可观察阵列列表（）创建一个由数组列表支持的新空可观察列表。可观察阵列列表（E…项）创建一个新的可观察数组列表，其中添加了项。

更新Java 9

在Java 9中也有一点简单：

List<String>List=List.of（“element 1”，“element 2”，“element 3”）；

Answer 17

您还可以使用Java8中的流来实现这一点。

List<Element>elements=Arrays.stream（array）.collect（Collectors.toList（））；

Answer 18

1. 如果我们看到数组.asList（）方法将得到如下结果：

   public static列表asList（T…a）//varargs属于T类型。

   所以，您可以初始化数组表这样地：

   List<Element>arraylist=Arrays.asList（新元素（1）、新元素（2）、新元（3））；

   注释：每个新元素（int args）将被视为单个对象，并可以作为var-args变量.

2. 这个问题也可能有另一个答案。
   如果您看到的是java.util（实用程序）。集合.addAll（）方法将得到如下结果：

   public static<T>boolean addAll（集合<？super T>c，T…a）；

   因此，此代码也很有用

   Collections.addAll（数组列表，数组）；

Answer 19

如果数组是基元类型，则给定的答案将不起作用。但由于Java 8，您可以使用：

int[]数组=新int[5]；Arrays.stream（array）.boxed（）.collect（Collectors.toList（））；

Answer 20

另一种简单的方法是使用for-each循环将数组中的所有元素添加到新的ArrayList。

ArrayList<Element>list=new ArrayList<>（）；for（元素e:数组）列表。添加（e）；

Answer 21

我们可以很容易地将数组转换为数组列表.我们使用Collection接口的添加全部（）方法，用于将内容从一个列表复制到另一个列表。

数组列表arr=新数组列表（）；arr.addAll（Arrays.asList（资产））；

Answer 22

尽管这个问题有很多完美的答案，但我会补充我的意见。

说你有元素[]数组={新元素（1），新元素（2），新元（3）}；

可以通过以下方式创建新的ArrayList

ArrayList（Arrays.asList（array））；ArrayList<Element>ArrayList_2=new Array列表(Arrays.asList（新元素[]{newElement（1），新元素（2），新元（3）}）；//通过集合添加ArrayList<Element>ArrayList_3=new ArrayList<>（）；Collections.addAll（arraylist_3，array）；

并且它们很好地支持ArrayList的所有操作

arraylist_1.add（新元素（4））；//or remove（）：成功arraylist_2.add（新元素（4））；//or remove（）：成功arraylist_3.add（新元素（4））；//or remove（）：成功

但以下操作只返回ArrayList的List视图，而不是实际的Array列表。

//返回数组的列表视图，而不是实际的ArrayListList<Element>listView_1=（List<Element>）数组.asList（数组）；List<Element>listView_2=Arrays.asList（array）；List<Element>listView_3=Arrays.asList（新元素（1）、新元素（2）、新元（3））；

因此，当尝试进行一些ArrayList操作时，它们会出错

listView_1.add（新元素（4））；//错误listView_2.add（新元素（4））；//错误listView_3.add（新元素（4））；//错误

关于数组的列表表示的更多信息链接.

Answer 23

最简单的方法是添加以下代码。经过尝试和测试。

String[]Array1=｛“一”、“二”、“三”｝；ArrayList<String>s1=新的ArrayList<String>（Arrays.asList（Array1））；

Answer 24

另一个Java8解决方案（我可能在大群人中错过了答案。如果是这样，我道歉）。这将创建一个ArrayList（与List相反），即可以删除元素

包包org.something.util；导入java.util。数组列表；导入java.util。阵列；导入java.util。列表；导入java.util.stream。收集器；公务舱垃圾{静态数组列表{return Arrays.asList（arr）.流（）.collect（Collectors.toCollection（ArrayList:：new））；}公共静态void main（String[]args）{String[]sArr=new String[]{“Hello”，“crime”，“world”}；列表<String>ret=arrToArrayList（sArr）；//验证是否可以删除项目并打印列表进行验证重新拆卸（1）；回流（）.forEach（System.out:：println）；}}

输出是。。。
你好
世界

Answer 25

您可以在java8中这样做

ArrayList<Element>list=（ArrayList<Element>）Arrays.stream（array）.collect（Collectors.toList（））；

Answer 26

给定对象数组：

元素[]数组＝{新元素（1），新元素（2），新元素（3），新元素（2）}；

将数组转换为列表：

List<Element>List=Arrays.stream（array）.collect（Collectors.toList（））；

将数组转换为ArrayList

ArrayList<Element>ArrayList=Arrays.stream（数组）.collect（Collectors.toCollection（ArrayList:：new））；

将数组转换为LinkedList

LinkedList<Element>LinkedList=Arrays.stream（数组）.collect（Collectors.toCollection（LinkedList:：new））；

打印列表：

list.forEach（元素->{System.out.println（element.i）；});

输出

1

2

三

Answer 27

使用以下代码将元素数组转换为ArrayList。

元素[]数组={新元素（1），新元素（2），新元（3）}；ArrayList<Element>elementArray=new ArrayList（）；for（int i=0；i<array.length；i++）{elementArray.add（数组[i]）；}

Answer 28

每个人已经为你的问题提供了足够好的答案。现在，根据所有建议，您需要决定哪一个符合您的要求。您需要了解两种类型的集合。一个是未修改的集合，另一个是允许您稍后修改对象的集合。

所以，这里我将给出两个用例的简短示例。

• 不可变集合创建：：创建后不想修改集合对象时

  List<Element>elementList=Arrays.asList（数组）

• 可变集合创建：：当您可能希望在创建后修改创建的集合对象时。

  列表<Element>elementList=new ArrayList<Element>（Arrays.asList（array））；

Answer 29

Java8的Arrays类提供了一个stream（）方法，该方法具有接受基本数组和对象数组的重载版本。

/****将基元“int”数组转换为列表****/int intArray[]={1，2，3，4，5}；List<Integer>integerList1=Arrays.stream（intArray）.boxed（）.collect（Collectors.toList（））；/****“IntStream.of”或“Arrays.stream”提供相同的输出****/List<Integer>integerList2=IntStream.of（intArray）.boxed（）.collect（Collectors.toList（））；/****将“整数”数组转换为列表****/整数整数数组[]={1，2，3，4，5，6，7，8，9，10}；List<Integer>integerList3=Arrays.stream（integerArray）.collect（Collectors.toList（））；

Answer 30

你也可以使用多态性宣布数组列表调用时阵列-接口如下：

列表<Element>arraylist=new arraylist<Integer>（Arrays.asList（array））；

例子：

Integer[]数组=｛1｝；//自动包装List＜Integer＞arraylist＝new arraylist＜Integer＞（Arrays.asList（array））；

这应该很有魅力。