您可以使用以下说明：

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

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

确保该类型与 相同。例如，如果您尝试从 的数组创建一个 ，则会出现编译器错误。myArrayTList<Integer>int

您可能只需要一个 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 返回的列表具有固定大小。因此，如果您希望能够在代码中添加或删除返回列表中的元素，则需要将其包装在新的 .否则，你会得到一个 .ArrayListUnsupportedOperationException
2. 返回的列表由原始数组支持。如果修改原始数组，列表也会被修改。这可能令人惊讶。asList()

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

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

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

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

Collections.addAll(arraylist, array);

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

如果可以的话，使用番石榴

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

用法

对于不可变列表

使用 ImmutableList 类及其 of（） 和 copyOf（） 工厂方法^{（元素不能为 null）：}

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

对于可变列表

使用 Lists 类及其 newArrayList（） 工厂方法：

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

另请注意其他类中其他数据结构的类似方法，例如在 Sets 中。

为什么选择番石榴？

主要的吸引力可能是减少由于类型安全泛型而导致的混乱，因为使用 Guava 工厂方法允许在大多数时候推断类型。然而，自从 Java 7 与新的 diamond 运算符一起出现以来，这个论点就站不住了。

但这并不是唯一的原因（Java 7 还不是无处不在）：速记语法也非常方便，如上所示，方法初始化器允许编写更具表现力的代码。您可以在一个 Guava 调用中执行当前 Java 集合需要 2 个调用。

---

如果你不能...

对于不可变列表

使用 JDK 的 Arrays 类及其 asList（） 工厂方法，用 Collections.unmodifiableList（） 包装：

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

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

它禁止通过某些 API 方法进行修改，只需扩展 （因此，不支持添加或删除元素），但它允许调用 覆盖元素。因此，此列表并不是真正不可变的，对 的调用应用 括起来。ListAbstractListset()asList()Collections.unmodifiableList()

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

对于可变列表

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

List<String> l1  = new ArrayList<String>(Arrays.asList(array));    // Java 1.5 to 1.6
List<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.6
List<String> l2b = new ArrayList<>(Arrays.asList("a", "b"));       // Java 1.7+

---

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

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

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

如果您使用：

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

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

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

// in Arrays
@SafeVarargs
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}
//still in Arrays, creating a private unseen class
private static class ArrayList<E>

    private final E[] a;    
    ArrayList(E[] array) {
        a = array; // you point to the previous array
    }
    ....
}

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

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

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

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

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

我喜欢用 、 或番石榴。但是，如果它不合适，或者你感觉不到，就再写一行不优雅的行。CollectionsArrays

另一个更新，即将在2014年结束，你也可以用Java 8来做：

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

您也可以在 Java 8 中使用 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);
   

爪哇 9

在 Java 9 中，您可以使用 List.of 静态工厂方法来创建文字。类似于以下内容：List

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

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

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

---

JEP 269：收集的便利工厂方法

JEP 269 为 Java 集合 API 提供了一些方便的工厂方法。这些不可变的静态工厂方法内置于 Java 9 及更高版本的 List、Set 和 Map 接口中。

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

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

2. List<Element> list = new ArrayList();
Collections.addAll(list, array);

3. Arraylist list = new Arraylist();
list.addAll(Arrays.asList(array));

有关更多详细信息，您可以参考 http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

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

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

创建数组的常见最新方法是 observableArrays

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

对于 Java SE，您可以尝试

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

这是根据 Oracle Docs

observableArrayList（） 创建一个由 arraylist 支持的新空可观察对象列表。 observableArrayList（E... 项） 创建一个新的可观察数组列表，并向其添加项。

更新 Java 9

同样在 Java 9 中，它有点简单：

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 collection
ArrayList<Element> arraylist_3 = new ArrayList<>();
Collections.addAll(arraylist_3, array);

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

arraylist_1.add(new Element(4)); // or remove(): Success
arraylist_2.add(new Element(4)); // or remove(): Success
arraylist_3.add(new Element(4)); // or remove(): Success

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

// Returns a List view of array and not actual ArrayList
List<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)); // Error
listView_2.add(new Element(4)); // Error
listView_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 so
        ret.remove(1);
        ret.stream()
            .forEach(System.out::println);
    }
}

输出是...
你好
，世界

你可以创建一个使用 Cactoos（我是开发人员之一）：ArrayList

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

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

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

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

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

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

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

Java 8 的 Arrays 类提供了一个 stream（） 方法，该方法具有接受原始数组和 Object 数组的重载版本。

/**** 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 表达式，它生成一个类型
为 （1） 的列表，而不进行未经检查的强制转换
（2），而不创建第二个列表（使用 eg.ArrayList<Element>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));

将数组转换为 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));

嗨，您可以使用这行代码，这是最简单的方法

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

或者，如果您使用 Java 9，您也可以使用以下方法：

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

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

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 1
List<String> list = Arrays.asList(array);          

//Method 2
List<String> list1 = new ArrayList<String>();
Collections.addAll(list1, array);

//Method 3
List<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());

您还可以在调用 Arrays-interface 时使用多态性来声明 ArrayList，如下所示：

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

例：

Integer[] array = {1};    // autoboxing
List<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 {

    @SafeVarargs
    public 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]]]
    }
}

番石榴使用相同的方法，因此在这里似乎是安全的。另请参阅 Java SafeVarargs 注解，是否存在标准或最佳实践？。@SafeVarargs

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

List<Element> list = List.of(array);

或

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

无论哪种方式，我们都可以将其转换为列表。