从数组创建ArrayList

我有一个初始化的数组,如:

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

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

ArrayList arraylist = ???;

Tom.. 4449

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

是的.在(最常见的)你只想要一个列表的情况下,`new ArrayList`调用也是不必要的. (352认同)

@Calum和@Pool - 如下所述,在Alex Miller的回答中,使用`Arrays.asList(array)`而不将其传递给新的`ArrayList`对象将修复列表的大小.使用`ArrayList`的一个常见原因是能够动态地改变它的大小,你的建议会阻止这种情况. (240认同)

@Luron - 只需使用`List list = Arrays.asList(array)` (137认同)

Arrays.asList()是一个可怕的函数,你永远不应该只使用它的返回值.它打破了List模板,所以总是以这里指出的形式使用它,即使它看起来多余.好答案. (126认同)

@Adam请研究java.util.List的javadoc.add的合约允许它们抛出UnsupportedOperationException.http://docs.oracle.com/javase/7/docs/api/java/util/List.html#add%28E%29不可否认,从面向对象的角度来看,很多时候你不得不这么做了解具体实现以便使用集合 - 这是一个实用的设计选择,以保持框架简单. (80认同)

@Adam`Arrays.asList()`是一个非常有用的方法,当你想要一个特定数组支持的列表时.例如`Collections.shuffle(Arrays.asList(myarray))`shuffle*original*array. (14认同)

我想指出,如果要使用迭代器执行mutative(如remove)操作,则需要新的ArrayList (...)部分. (13认同)

需要注意的是:我只是遇到了Java 6的不当行为:当Element是一个原语(例如数组是int [])时,asList创建了List . (12认同)

@Arkadiy当`a`是`int []`时,`Arrays.asList(a).get(0)== a`并不是一个错误.这是因为`asList(Object ...)`varargs如何解析.一个类型为`int []`的对象是一个`Object`,而不是一个`Object []`,所以`Arrays.asList`正在传递一个带有一个元素的`Object`数组:一个`int`数组. (7认同)

当数组的类型为`int []`并且等效的用例如下时,这不会编译:`List intList = new ArrayList (Arrays.asList(intArray));` (5认同)

@lbalazscs是真的,但我会说这非常接近黑客(即使shuffle方法是打算以这种方式使用),因为你基本上是在欺骗它,因为它认为它处理的是List而不是.很方便,但我仍然说这是一个可怕的功能.我的论点基本上是asList()方法具有误导性,因为它看起来像返回给定数组的List表示,而实际上它返回一个仅部分实现的List表示. (4认同)

@AndrewF我明白为什么会这样.这只是为我打破DWIM,就是这样. (3认同)

Arrays.asList(array).remove(key)将抛出:`java.util.AbstractList.remove(AbstractList.java:161)中的线程"main"java.lang.UnsupportedOperationException中的异常...` - dunno how [ `AbstractList`](http://docs.oracle.com/javase/7/docs/api/java/util/AbstractList.html)进入那里,但是在调用remove时你不想要它 (3认同)

对于数组为基本类型（例如int []）的情况，请参见以下问题：http://stackoverflow.com/questions/1073919/how-to-convert-int-into-listinteger-in-java (3认同)

另外,`List list = new ArrayList <>(Arrays.asList(array));`就足够了.[diamond](http://stackoverflow.com/questions/4166966/what-is-the-point-of-the-diamond-operator-in-java-7)运算符将为您执行类型推断. (3认同)

这对Java 1.8不起作用.在Java 1.8中,`Arrays.asList(array)`将创建一个列表,其唯一的元素是`array`.结果列表不包含`array`的元素. (3认同)

Alex Miller.. 874

鉴于:

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

最简单的答案是:

List list = Arrays.asList(array);

这样可以正常工作.但有些警告:

从asList返回的列表具有固定大小.因此,如果您希望能够在代码中添加或删除返回列表中的元素,则需要将其包装在新代码中ArrayList.否则你会得到一个UnsupportedOperationException.

返回的列表asList()由原始数组支持.如果修改原始数组,则也会修改列表.这可能会令人惊讶.

Arrays.asList()只是通过包装现有数组来创建一个ArrayList,因此它是O(1). (30认同)

包装新的ArrayList()将导致固定大小列表的所有元素被迭代并添加到新的ArrayList,因此是O(n). (22认同)

asList()返回的List的实现没有实现List的几个方法(如add(),remove(),clear()等等),这解释了UnsupportedOperationException.绝对是一个警告...... (8认同)

当问题要求"ArrayList类的一个对象"时,我认为假设它引用的类是`java.util.ArrayList`是合理的.Arrays.asList实际上返回一个`java.util.Arrays.ArrayList`,它不是另一个类的`instanceof`.所以第三个警告是,如果你试图在需要上述内容的环境中使用它,它将无法工作. (8认同)

两种操作的时间复杂度是多少？我的意思是使用和不使用明确的arraylist结构. (5认同)

haylem.. 338

^{(老线程,但只有2美分,因为没有提到番石榴或其他图书馆和其他一些细节)}

值得指出的是Guava方式,它极大地简化了这些恶作剧:

用法

对于不可变列表

使用ImmutableList类及其of()与copyOf()工厂方法^{(内容不能为空)}:

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

对于可变列表

使用Lists类及其newArrayList()工厂方法:

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

还请注意其他类中其他数据结构的类似方法,例如Sets.

为何选择番石榴？

主要的吸引力可能是减少因类型安全的仿制药造成的混乱,因为使用番石榴工厂方法可以在大多数时间推断出类型.然而,自Java 7与新的钻石操作员到达以来,这个论点持有的水量更少.

但这并不是唯一的原因(并且Java 7还没有到处):简写语法也非常方便,如上所述,方法初始化器允许编写更具表现力的代码.你在一个Guava调用中执行当前Java集合需要2.

对于不可变列表

使用JDK的Arrays类及其asList()工厂方法,包含Collections.unmodifiableList():

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

// for Java 1.5+
static  List arrayToList(final T[] array) {
  final List l = new ArrayList(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);
}

+1但请注意,`Arrays.asList`返回的`List`是可变的,因为你仍然可以`set`元素 - 它只是不可调整大小.对于没有Guava的不可变列表,你可能会提到[`Collections.unmodifiableList`](http://docs.oracle.com/javase/7/docs/api/java/util/Collections.html#unmodifiableList \(java.util.List) \)). (26认同)

Tim Büthe.. 218

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

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

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

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

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

List list = Arrays.asList(array);

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

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

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

List l1  = new ArrayList(Arrays.asList(array));    // Java 1.5 to 1.6
List l1b = new ArrayList<>(Arrays.asList(array));          // Java 1.7+
List l2  = new ArrayList(Arrays.asList("a", "b")); // Java 1.5 to 1.6
List l2b = new ArrayList<>(Arrays.asList("a", "b"));       // Java 1.7+

// for Java 1.5+
static  List arrayToList(final T[] array) {
  final List l = new ArrayList(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);
}

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

new ArrayList(Arrays.asList(myArray));

Collections.addAll(arraylist, array);

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

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

List arraylist = Arrays.asList(array);

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

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

new ArrayList(Arrays.asList(myArray));

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

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

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

new ArrayList(Arrays.asList(myArray));

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

ArrayList arraylist = new ArrayList(Arrays.asList(array));

List arraylist = Arrays.asList(array);

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

 new ArrayList<>(Arrays.asList("1","2","3","4"));

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

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

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

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

ArrayList list = new ArrayList<>();

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

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

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

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

// Add through a collection
ArrayList arraylist_3 = new ArrayList<>();
Collections.addAll(arraylist_3, array);

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

// Returns a List view of array and not actual ArrayList
List listView_1 = (List) Arrays.asList(array);
List listView_2 = Arrays.asList(array);
List listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3));

listView_1.add(new Element(4)); // Error
listView_2.add(new Element(4)); // Error
listView_3.add(new Element(4)); // Error

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

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

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  ArrayList  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 ret = arrToArrayList(sArr);
        // Verify one can remove an item and print list to verify so
        ret.remove(1);
        ret.stream()
            .forEach(System.out::println);
    }
}