如果可以，请使用番石榴

Question

我有一个初始化的数组，如：

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

我想将此数组转换为ArrayList类的对象。

ArrayList<Element> arraylist = ???;

Answer 1

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

Answer 2

假设：

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

最简单的答案是：

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

这样可以正常工作。但有些警告：

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

Answer 3

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

如果可以，请使用番石榴

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

用法

对于不可变列表

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

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。

Why Guava?

主要的吸引力可能是减少因类型安全的泛型而造成的混乱，因为使用番石榴factory methods允许在大多数时间推断类型。然而，自从Java 7与新的钻石操作员一起到达以来，这个论点含有较少的水。

但这不是唯一的原因（并且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"));

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

它禁止通过一些List API的方法进行修改，只需简单地扩展AbstractList（因此，不支持添加或删除元素），但它允许调用set()覆盖元素。因此，此列表并非真正不可变，并且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);
}

Answer 4

由于这个问题已经很久了，所以没有人提出最简单的表格让我感到惊讶：

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

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

Answer 5

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

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

Answer 6

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

Collections.addAll(arraylist, array);

Answer 7

Java 9

在Java 9中，您可以使用List.of静态工厂方法来创建List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));字面值。如下所示：

ArrayList

这将返回包含三个元素的immutable列表。如果您需要可变列表，请将该列表传递给new ArrayList<>(List.of(// elements vararg))构造函数：

apply(String.to_existing_atom("Elixir.Module"), :helloWorld, [])

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

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

Answer 8

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

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

Answer 9

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

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

如果这只是List

，则会保存一些字符

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

Answer 10

如果您使用：

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

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

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

// 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
    }
    ....
}

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

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

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

我喜欢使用Collections，Arrays或番石榴。但如果它不适合，或者你感觉不适合，那就改写另一条不优雅的线。

Answer 11

在Java 9中，您可以使用：

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

Answer 12

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

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

但最好总是使用界面：

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

Answer 13

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

Answer 14

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

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

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

Answer 15

正如所有人所说，这样做

 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 ... items）创建一个新的可观察数组列表，其中添加了项目。

更新Java 9

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

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

Answer 16

您也可以使用Java 8中的流来完成。

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

Answer 17

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

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

Answer 18

如果我们看到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传递。
这个问题可能还有另一个答案如果您看到java.util.Collections.addAll()方法的声明，您将得到类似的结果：
```
public static <T> boolean addAll(Collection<? super T> c, T... a);
```
所以，这段代码也很有用
```
Collections.addAll(arraylist, array);
```

Answer 19

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

ArrayList<Element> list = new ArrayList<>();

for(Element e : array)
    list.add(e);

Answer 20

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

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

Answer 21

使用以下代码将元素数组转换为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]);
}

Answer 22

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

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

Answer 23

即使这个问题有很多完美的书面答案，我也会加入我的输入。

说你有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

有关数组link的列表表示的更多信息。

Answer 24

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

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

Answer 25

另一个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);
    }
}

输出是......
你好
世界

Answer 26

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

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

Answer 27

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

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

不可变集合创建::如果您不想在创建后修改集合对象

List<Element> elementList = Arrays.asList(array)
可变集合创建::当您想要在创建后修改创建的集合对象时。

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

Answer 28

在Java中，主要有3种方法将 array 转换为 arrayList

使用Arrays.asList（）方法：将所需的数组传递给此方法，并获取一个List对象，并将其作为参数传递给ArrayList类的构造函数。
```
List<String> list = Arrays.asList(array);                   
System.out.println(list);
```
Collections.addAll（）方法-使用此方法之前创建一个新列表，然后使用此方法将数组元素添加到现有列表中。
```
 List<String> list1 = new ArrayList<String>();
 Collections.addAll(list1, array);
 System.out.println(list1);
```

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

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

您也可以参考this document

Answer 29

下面的代码似乎是实现此目的的好方法。

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

Answer 30

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

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

示例：

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

这应该很有魅力。

Answer 31

您可以使用Cactoos创建ArrayList（我是其中一位开发人员）：

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

无法保证对象实际上属于类ArrayList。如果您需要这种保证，请执行以下操作：

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

Answer 32

对于普通大小的数组，上述答案适用。如果您拥有庞大的数组并使用Java 8，则可以使用流来实现。

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

Answer 33

还有另一种方法可用于将数组转换为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;
    }

Answer 34

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

Code    date    temperature

Answer 35

使用以下脚本

Object[] myNum = {10, 20, 30, 40};
List<Object> newArr = new ArrayList<>(Arrays.asList(myNum));

Answer 36

嗨，您可以使用此 line of code ，这是最简单的方法

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

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

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

Answer 37

这是第一个也是最简单的方法

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

另一种方法

//declare myarray
ArrayList <String> ar = new ArrayList<String> ();
for(String s : myArray){
    ar.add(s);
}

这是遍历数组并分别添加每个元素

此处使用的for循环称为增强的for循环

Answer 38

给出对象数组：

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

将数组转换为列表：

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

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

Answer 39

生成类型列表的lambda表达式 ArrayList<Element>
（1）没有未经检查的演员表
（2）而不创建第二个列表（例如asList()）

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

Answer 40

这是3种方法。.可能有用。

    Arrays.asList("yellow", "green","blue");

    Collections.singletonList(new String[]{"yellow", "green","blue"});

    Arrays.stream((new String[]{"yellow", "green", "blue"})).collect(Collectors.toList());

Answer 41

Java 8的Arrays类提供了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());

Answer 42

这是一个明确的方法

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

Answer 43

使用以下代码

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

Answer 44

如果您的目标是在运行时生成一个固定列表，那么还有另一种选择，这很简单：

static final ArrayList<Element> myList = generateMyList();

private static ArrayList<Element> generateMyList() {
  final ArrayList<Element> result = new ArrayList<>();
  result.add(new Element(1));
  result.add(new Element(2));
  result.add(new Element(3));
  result.add(new Element(4));
  return result;
}

使用这种模式的好处是，列表非常直观地生成，因此即使使用大型列表或复杂的初始化也很容易修改，而另一方面，在程序的每次实际运行时总是包含相同的元素（除非你在以后更改它。）

从数组创建ArrayList

44 个答案:

如果可以，请使用番石榴

用法

对于不可变列表

对于可变列表

Why Guava?

如果你不能......

对于不可变列表

对于可变列表

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

Java 9

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

更新Java 9