从数组创建ArrayList

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

ArrayList<Element> arraylist = ???;

#1 楼

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

#2 楼

给出：

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

最简单的答案是：

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

这将很好地工作。但有一些警告：


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

#3 楼

（旧线程，但只有2美分，没有提到Guava或其他库以及其他一些细节）

如果可以的话，请使用Guava

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

用法

对于不可变列表

使用ImmutableList类及其of()和copyOf()工厂方法（元素可以通过t为空）：

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

为什么使用番石榴？

主要的吸引力可能是由于类型安全的泛型而减少了混乱，因为使用番石榴工厂方法可以在大多数时间推断类型。但是，自从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"));

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

它禁止通过简单扩展ArrayList的方式通过List API的某些方法进行修改（因此，不支持添加或删除元素），但是它允许调用AbstractList来覆盖元素。因此，此列表并非真正不变，因此对set()的调用应使用asList()进行包装。

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

获取可变列表

与上述相同，但包裹有实际的Collections.unmodifiableList()：

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

#4 楼

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

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

从Java 5开始，Arrays.asList()带有varargs参数，而您没有必须显式构造数组。

#5 楼

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

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

#6 楼

另一种方法（虽然本质上等效于new ArrayList(Arrays.asList(array))解决方案的性能：

Collections.addAll(arraylist, array);

#7 楼

Java 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接口中。

#8 楼

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

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

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

#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：我喜欢使用Collections，Arrays或Guava。但是，如果不合适，或者您感觉不到，只需改写另一条优雅的行即可。

#11 楼

在Java 9中，您可以使用：

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

#12 楼

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

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

但是最好总是使用以下接口：

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

#13 楼

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

#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

#15 楼

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

#16 楼

正如所有人所说的那样

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

#17 楼

您也可以在Java 8中使用流来实现它。

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

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

#19 楼

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

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

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

#20 楼

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

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

#21 楼

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

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

#22 楼

即使有很多关于该问题的书面答案，我也将添加我的意见。

假设您有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的列表视图，而不返回实际的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

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

#23 楼

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

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

#24 楼

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

输出为...
你好
世界

#25 楼

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

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

#26 楼

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

#27 楼

给定的对象数组：

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

#28 楼

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

因此，在这里，我将给出两个用例的简短示例。



创建不可变的集合::何时不想在创建后修改集合对象

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



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

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

#29 楼

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

#30 楼

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

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