new ArrayList<>(Arrays.asList(array));

new ArrayList<T>(Arrays.asList(myArray));

确保myArray与T的类型相同。例如，如果您尝试从int的数组创建List<Integer>，您将收到编译器错误。

你可能只需要一个List，而不是ArrayList。在这种情况下，你可以这样做：

List<Element> arraylist = Arrays.asList(array);

给定：

Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };

最简单的答案是：

List<Element> list = Arrays.asList(array);

这将工作正常。但一些警告：

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

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

List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

从Java5开始，Arrays.asList()采用varargs参数，您不必显式构造数组。

另一种方式（尽管在性能方面基本上等同于new ArrayList(Arrays.asList(array))解决方案：

Collections.addAll(arraylist, array);

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

如果可以，使用番石榴

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

用法

对于不可变列表

使用#0类及其#1和#2工厂方法^{（元素不能为空）}：

List<String> il = ImmutableList.of("string", "elements");  // from varargsList<String> il = ImmutableList.copyOf(aStringArray);      // from array

对于可变列表

使用#0类及其#1工厂方法：

List<String> l1 = Lists.newArrayList(anotherListOrCollection);    // from collectionList<String> l2 = Lists.newArrayList(aStringArray);               // from arrayList<String> l3 = Lists.newArrayList("or", "string", "elements"); // from varargs

还请注意其他类中其他数据结构的类似方法，例如#0。

为什么是番石榴？

主要的吸引力可能是为了减少类型安全的泛型造成的混乱，因为使用Guava工厂方法可以在大部分时间内推断类型。然而，自从Java7与新的钻石操作员一起到达以来，这个论点就不那么站得住脚了。

但这并不是唯一的原因（Java7还不是无处不在）：简写语法也非常方便，方法初始化器，如上所述，允许编写更具表现力的代码。

如果你不能…

对于不可变列表

使用JDK的#0类及其#1工厂方法，用#2包装：

List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));

请注意，asList()的返回类型是使用具体ArrayList实现的List，但它不是java.util.ArrayList。它是一个内部类型，它模拟ArrayList，但实际上直接引用传递的数组并使其“写入”（修改反映在数组中）。

它禁止通过简单扩展AbstractList的方式修改List API的一些方法（因此，不支持添加或删除元素），但它允许对set()的调用覆盖元素。因此，这个列表不是真正不可变的，对asList()的调用应该用Collections.unmodifiableList()包装。

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

对于可变列表

与上面相同，但用实际的java.util.ArrayList包装：

List<String> l1  = new ArrayList<String>(Arrays.asList(array));    // Java 1.5 to 1.6List<String> l1b = new ArrayList<>(Arrays.asList(array));          // Java 1.7+List<String> l2  = new ArrayList<String>(Arrays.asList("a", "b")); // Java 1.5 to 1.6List<String> l2b = new ArrayList<>(Arrays.asList("a", "b"));       // Java 1.7+

用于教育目的：良好的ol'手动方式

// for Java 1.5+static <T> List<T> arrayToList(final T[] array) {final List<T> l = new ArrayList<T>(array.length);
for (final T s : array) {l.add(s);}return (l);}
// for Java < 1.5 (no generics, no compile-time type-safety, boo!)static List arrayToList(final Object[] array) {final List l = new ArrayList(array.length);
for (int i = 0; i < array.length; i++) {l.add(array[i]);}return (l);}

// Guavaimport com.google.common.collect.ListsLists...List<String> list = Lists.newArrayList(aStringArray);

如果您使用：

new ArrayList<T>(Arrays.asList(myArray));

你可能创建和填补两个列表！填充两次大列表正是你不想做的，因为每次需要扩展容量时它都会创建另一个Object[]数组。

幸运的是，JDK实现很快，Arrays.asList(a[])做得很好。它创建了一种名为Arrays. ArrayList的ArrayList，其中Object[]数据直接指向数组。

// in Arrays@SafeVarargspublic static <T> List<T> asList(T... a) {return new ArrayList<>(a);}//still in Arrays, creating a private unseen classprivate static class ArrayList<E>
private final E[] a;ArrayList(E[] array) {a = array; // you point to the previous array}....}

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

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

ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacityfor (Element element : myArray) {list.add(element);}

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

new ArrayList<T>(Arrays.asList(myArray));

我喜欢用Collections、Arrays或番石榴。但是如果它不合适，或者你感觉不到，就写另一个不优雅的行代替。

另一个更新，几乎结束2014年，你也可以用Java8做到这一点：

ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));

将保存一些字符，如果这可能只是一个List

List<Element> list = Stream.of(myArray).collect(Collectors.toList());

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

ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));

但是，最好始终使用接口：

List<Element> arraylist = Arrays.<Element>asList(array);

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

ArrayList<Element> list = new ArrayList<>();
for(Element e : array)list.add(e);

您也可以在Java8中使用stream。

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList());

1. 如果我们看到Arrays.asList()方法的定义，你会得到这样的东西：

    public static <T> List<T> asList(T... a) //varargs are of T type.

   所以，你可以像这样初始化arraylist：

    List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

   说明：每个new Element(int args)将被视为单个对象，并且可以作为var-args传递。

2. 这个问题可能还有另一个答案。
   如果你看到java.util.Collections.addAll()方法的声明，你会得到这样的东西：

   public static <T> boolean addAll(Collection<? super T> c, T... a);

   所以这段代码也很有用

   Collections.addAll(arraylist, array);

Java9

在Java9中，您可以使用#0静态工厂方法来创建List文字。如下所示：

List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));

这将返回一个包含三个元素的不可变列表。如果你想要一个可变列表，请将该列表传递给ArrayList构造函数：

new ArrayList<>(List.of(// elements vararg))

JEP 269：便利工厂收集方法

jep269为Java收藏 API提供了一些方便的工厂方法。这些不可变的静态工厂方法内置在Java9和更高版本的#0、#1和#2接口中。

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

1. List<Element> list = Arrays.asList(array);

2. Listlist=new ArrayList（）；
Collections.add所有（列表，数组）；

3. Arraylist list=new Arraylist（）；
list.addAll（Arrays.as列表（数组））；

更多细节可以参考http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

从Java8开始，有一种更简单的转换方法：

import java.util.List;import static java.util.stream.Collectors.toList;
public static <T> List<T> fromArray(T[] array) {return Arrays.stream(array).collect(toList());}

就像所有人说的那样

 new ArrayList<>(Arrays.asList("1","2","3","4"));

创建数组的常见最新方法是可观察数组

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

Java你可以试试

FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3));

这是根据oracledocs

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

更新Java9

同样在Java9中，它有点简单：

List<String> list = List.of("element 1", "element 2", "element 3");

尽管这个问题有很多完美的书面答案，但我会补充我的输入。

说你有Element[] array = { new Element(1), new Element(2), new Element(3) };

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

ArrayList<Element> arraylist_1 = new ArrayList<>(Arrays.asList(array));ArrayList<Element> arraylist_2 = new ArrayList<>(Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) }));
// Add through a collectionArrayList<Element> arraylist_3 = new ArrayList<>();Collections.addAll(arraylist_3, array);

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

arraylist_1.add(new Element(4)); // or remove(): Successarraylist_2.add(new Element(4)); // or remove(): Successarraylist_3.add(new Element(4)); // or remove(): Success

但以下操作仅返回ArrayList的List视图，而不是实际的ArrayList。

// Returns a List view of array and not actual ArrayListList<Element> listView_1 = (List<Element>) Arrays.asList(array);List<Element> listView_2 = Arrays.asList(array);List<Element> listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3));

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

listView_1.add(new Element(4)); // ErrorlistView_2.add(new Element(4)); // ErrorlistView_3.add(new Element(4)); // Error

更多关于数组链接的列表表示。

在Java 9中，您可以使用：

List<String> list = List.of("Hello", "World", "from", "Java");List<Integer> list = List.of(1, 2, 3, 4, 5);

最简单的方法是添加以下代码。

String[] Array1={"one","two","three"};ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));

您可以在Java 8中执行以下操作

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());

另一个Java8解决方案（我可能错过了一大堆答案。如果是这样，我道歉）。这创建了一个ArrayList（而不是List），即可以删除元素

package package org.something.util;
import java.util.ArrayList;import java.util.Arrays;import java.util.List;import java.util.stream.Collectors;
public class Junk {
static <T> ArrayList<T>  arrToArrayList(T[] arr){return Arrays.asList(arr).stream().collect(Collectors.toCollection(ArrayList::new));}
public static void main(String[] args) {String[] sArr = new String[]{"Hello", "cruel", "world"};List<String> ret = arrToArrayList(sArr);// Verify one can remove an item and print list to verify soret.remove(1);ret.stream().forEach(System.out::println);}}

输出为…
你好
世界

您可以使用仙人掌创建ArrayList（我是开发人员之一）：

List<String> names = new StickyList<>("Scott Fitzgerald", "Fyodor Dostoyevsky");

不能保证对象实际上是类ArrayList。如果您需要这种保证，请执行以下操作：

ArrayList<String> list = new ArrayList<>(new StickyList<>("Scott Fitzgerald", "Fyodor Dostoyevsky"));

我们可以轻松地将数组转换为ArrayList。我们使用Collection接口的addAll()方法将内容从一个列表复制到另一个列表。

 Arraylist arr = new Arraylist();arr.addAll(Arrays.asList(asset));

如果数组是原始类型，则给定的答案将不起作用。但是从Java8开始，您可以使用：

int[] array = new int[5];Arrays.stream(array).boxed().collect(Collectors.toList());

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

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

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

  List<Element> elementList = Arrays.asList(array)

• 可变集合创建:: 当您可能想要在创建后修改创建的集合对象时。

  List<Element> elementList = new ArrayList<Element>(Arrays.asList(array));

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

Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element>elementArray=new ArrayList();for(int i=0;i<array.length;i++) {elementArray.add(array[i]);}

使用下面的代码

Element[] array = {new Element(1), new Element(2), new Element(3)};ArrayList<Element> list = (ArrayList) Arrays.asList(array);

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

/**** Converting a Primitive 'int' Array to List ****/
int intArray[] = {1, 2, 3, 4, 5};
List<Integer> integerList1 = Arrays.stream(intArray).boxed().collect(Collectors.toList());
/**** 'IntStream.of' or 'Arrays.stream' Gives The Same Output ****/
List<Integer> integerList2 = IntStream.of(intArray).boxed().collect(Collectors.toList());
/**** Converting an 'Integer' Array to List ****/
Integer integerArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
List<Integer> integerList3 = Arrays.stream(integerArray).collect(Collectors.toList());

生成类型列表的lambda表达式ArrayList<Element>
（1）没有未选中的强制转换
（2）不创建第二个列表（例如asList()）

ArrayList<Element> list = Stream.of( array ).collect( Collectors.toCollection( ArrayList::new ) );

给定对象数组：

Element[] array = {new Element(1), new Element(2), new Element(3) , new Element(2)};

将数组转换为列表：

    List<Element> list = Arrays.stream(array).collect(Collectors.toList());

转换Array到ArrayList

    ArrayList<Element> arrayList = Arrays.stream(array).collect(Collectors.toCollection(ArrayList::new));

将Array转换为LinkedList

    LinkedList<Element> linkedList = Arrays.stream(array).collect(Collectors.toCollection(LinkedList::new));

打印清单：

    list.forEach(element -> {System.out.println(element.i);});

输出

1

2

3

下面的代码似乎是这样做的好方法。

new ArrayList<T>(Arrays.asList(myArray));

嗨，你可以用这个#0，这是最简单的方法

 new ArrayList<>(Arrays.asList(myArray));

如果您使用#0，您也可以使用此方法：

List<String> list = List.of("Hello", "Java");List<Integer> list = List.of(1, 2, 3);

在java中，主要有3种方法可以将阵列转换为数组列表

1. 使用Arrays.asList（）方法：将所需的数组传递给此方法并获取List对象并将其作为参数传递给ArrayList类的构造函数。

   List<String> list = Arrays.asList(array);System.out.println(list);

2. Collections.addAll（）方法-在使用此方法之前创建一个新列表，然后使用此方法将数组元素添加到现有列表中。

    List<String> list1 = new ArrayList<String>();Collections.addAll(list1, array);System.out.println(list1);

3. 迭代方法-创建一个新列表。迭代数组并将每个元素添加到列表中。

    List<String> list2 = new ArrayList<String>();for(String text:array) {list2.add(text);}System.out.println(list2);

你也可以参考本文件

您可以使用以下3种方法从Array创建ArrayList。

  String[] array = {"a", "b", "c", "d", "e"};
//Method 1List<String> list = Arrays.asList(array);
//Method 2List<String> list1 = new ArrayList<String>();Collections.addAll(list1, array);
//Method 3List<String> list2 = new ArrayList<String>();for(String text:array) {list2.add(text);}

您还可以使用一种方法将数组转换为ArrayList。您可以遍历数组并将每个索引插入ArrayList并将其返回到ArrayList中。

如下所示。

public static void main(String[] args) {String[] array = {new String("David"), new String("John"), new String("Mike")};
ArrayList<String> theArrayList = convertToArrayList(array);}
private static ArrayList<String> convertToArrayList(String[] array) {ArrayList<String> convertedArray = new ArrayList<String>();
for (String element : array) {convertedArray.add(element);}
return convertedArray;}

对于正常大小的数组，上述答案适用。如果您有巨大的数组大小并使用java 8，您可以使用stream来完成。

  Element[] array = {new Element(1), new Element(2), new Element(3)};List<Element> list = Arrays.stream(array).collect(Collectors.toList());

您还可以使用多态在调用数组接口时声明数组列表，如下所示：

List<Element> arraylist = new ArrayList<Integer>(Arrays.asList(array));

示例：

Integer[] array = {1};    // autoboxingList<Integer> arraylist = new ArrayList<Integer>(Arrays.asList(array));

这应该像一个魅力。

使用Stream（从java 16开始）

new ArrayList<>(Arrays.stream(array).toList());

当我创建大量ArrayList并需要简洁的语法时，我使用了以下辅助方法：

import java.util.ArrayList;import java.util.Arrays;
class Main {
@SafeVarargspublic static <T> ArrayList<T> AL(T ...a) {return new ArrayList<T>(Arrays.asList(a));}
public static void main(String[] args) {var al = AL(AL(1, 2, 3, 4), AL(AL(5, 6, 7), AL(8, 9)));System.out.println(al); // => [[1, 2, 3, 4], [[5, 6, 7], [8, 9]]]}}

番石榴也用同样的方法所以@SafeVarargs在这里看起来是安全的。另见JavaSafeVarargs注释，是否存在标准或最佳实践？。

Element[] array = {new Element(1), new Element(2), new Element(3)};
List<Element> list = List.of(array);

或

List<Element> list = Arrays.asList(array);

两种方式我们都可以将其转换为列表。