从数组创buildArrayList

我有一个数组被初始化为：

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

这将工作正常。 但是有一些注意事项：

1. 从asList返回的列表具有固定大小 。 所以，如果你想在你的代码中添加或者移除返回列表中的元素，你需要把它包装在一个新的ArrayList 。 否则，你会得到一个UnsupportedOperationException 。
2. 从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 。

为什么番石榴？

主要的吸引力可能是减less由于types安全性generics造成的混乱，因为使用Guava 工厂方法可以在大多数情况下推断types。 然而，从Java 7到达新的钻石运营商以来，这个论点的用水量就减less了。

但并不是唯一的原因（Java 7并没有到处都是）：简写语法也非常方便，如上所述，方法初始化器允许编写更多expression式代码。 你可以在一个Guava中调用当前Java Collections的2个参数。

---

如果你不能…

对于不可变列表

使用包含Collections.unmodifiableList()的JDK的Arrays类和它的asList()工厂方法：

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

请注意， asList()的返回types是使用具体的ArrayList实现的List ，但它不是 java.util.ArrayList 。 这是一个内部types，它模拟一个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.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

由于这个问题是相当古老的，这让我感到惊讶，没有人提出最简单的forms：

 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相同。 例如，如果您尝试从int数组中创buildList<Integer> ，则会出现编译器错误。

Answer 6

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

 Collections.addAll(arraylist, array); 

Answer 7

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

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

Answer 8

另一个更新，几乎到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 9

为了将一个数组转换成一个ArrayList，开发人员经常这样做：

 List<String> list = Arrays.asList(arr);// this is wrong way.. 

Arrays.asList()将返回一个ArrayList，它是private static class inside Arrays一个private static class inside Arrays ，它不是java.util.ArrayList类。 The java.util.Arrays.ArrayList类有set(), get(), contains()方法，但没有任何添加元素的方法，所以它的大小是固定的。 要创build一个真正的ArrayList，你必须这样做：

 ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr)); 

ArrayList的构造函数可以接受一个Collectiontypes ，它也是java.util.Arrays.ArrayList一个超types

Answer 10

Java 9

在Java 9中 ，您可以使用List.of静态工厂方法来创build一个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为Collections API提供了一些便捷的工厂方法。 这个工厂方法不是在当前的Java版本中，它是8，而是为Java 9版本计划的。 您可以使用JDK 9 Early Access来试用此function。

Answer 11

如果你使用：

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

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

幸运的是，JDK的实现速度很快， Arrays.asList(a[])做得非常好。 它创build一种名为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所示，您可以创build另一个独立的ArrayList：

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

我喜欢用Collections ， Arrays或Guava。 但是，如果它不合适，或者你感觉不到，就写一条另一条不合适的线。

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

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

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

Answer 15

在Java 9您可以使用：

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

Answer 16

您也可以在Java 8中使用stream来完成。

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

Answer 17

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

Answer 18

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

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

Answer 19

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

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

Answer 20

而创build数组的最新常用方法是observableArrays

因此答案是

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

这是根据Oracle Docs

observableArrayList（）创build一个由arraylist支持的新的空可观察列表。 observableArrayList（E … items）创build一个新的可观察数组列表，并添加项目。

Answer 21

鉴于：

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

使用：

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

Answer 22

尽pipe这个问题有许多完美的答案，我会join我的投入。

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

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

 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 

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

Answer 23

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

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

Answer 24

另一个Java8解决scheme（我可能错过了大集合中的答案，如果是这样，我的道歉）。 这创build一个ArrayList（而不是一个列表），即可以删除元素

 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 25

我们可以很容易地将一个数组转换成ArrayList。 我们使用Collection接口的addAll（）方法来将内容从一个列表复制到另一个列表。

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

Answer 26

已经每个人都已经为你的问题提供了很好的答案。 现在从所有的build议，你需要决定哪些将符合你的要求。 有两种你需要知道的收集types。 一个是未修改的集合，另一个集合将允许您稍后修改对象。

所以，在这里我将举两个例子的简短例子。

• 不可变的集合创build::当你不想在创build后修改集合对象

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

• 可变集合的创build::当你可能想创build后修改创build的集合对象。

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

Answer 27

你可以在java 8中做到这一点，如下所示

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

Answer 28

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

Answer 29

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

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

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

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

Answer 30

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

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