从数组创buildArrayList

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

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

我想将这个数组转换成ArrayList类的一个对象。

 ArrayList<Element> arraylist = ???; 
 new 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()返回的列表由原始数组支持。 如果修改原始数组,则列表也会被修改。 这可能是令人惊讶的。

(旧的线程,但只有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); } 

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

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

从Java 5开始, Arrays.asList()需要一个varargs参数,而不必显式构造数组。

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

确保myArrayT相同。 例如,如果您尝试从int数组中创buildList<Integer> ,则会出现编译器错误。

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

 Collections.addAll(arraylist, array); 

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

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

另一个更新,几乎到2014年结束,你也可以用Java 8来完成:

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

如果这可能只是一个List ,几个字符将被保存

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

为了将一个数组转换成一个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

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。

如果你使用:

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

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

根据这个问题,使用java 1.7的答案是:

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

不过最好总是使用界面:

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

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

  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 9您可以使用:

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

您也可以在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); 

从Java 8开始,有更简单的方法来转换:

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

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

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

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

因此答案是

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

这是根据Oracle Docs

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

鉴于:

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

使用:

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

尽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 

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

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

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

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

输出是…
你好
世界

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

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

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

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

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

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

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

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

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

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

你可以使用Cactoos创build一个ArrayList (我是开发人员之一):

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

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

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

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

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