从数组创建ArrayList-Java 学习之路

3124

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

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

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

ArrayList<Element> arraylist = ???;

30 回答

65
鉴于：
```
Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };
```
最简单的答案是：
```
List<Element> list = Arrays.asList(array);
```
这样可以正常工作 . 但有些警告：
- 从asList返回的列表具有 fixed size . 因此，如果您希望能够在代码中添加或删除返回列表中的元素，则需要将其包装在新的 ArrayList 中 . 否则你会得到 UnsupportedOperationException .
- 从 asList() 返回的列表由原始数组支持 . 如果修改原始数组，则也会修改列表 . 这可能是令人惊讶的 .
回复于 2024-04-20T19:52:31+08:00
13
您可能只需要一个List，而不是ArrayList . 在这种情况下，您可以这样做：
```
List<Element> arraylist = Arrays.asList(array);
```
回复于 2024-04-20T19:52:31+08:00
4
另一种方式（虽然基本上等同于 new ArrayList(Arrays.asList(array)) 解决方案的性能方面：
```
Collections.addAll(arraylist, array);
```
回复于 2024-04-20T19:52:31+08:00

180

你可以在Arrays.asList（arrayObj）的帮助下轻松完成;

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

回复于 2024-04-20T19:52:31+08:00

5
我们可以轻松地将数组转换为 ArrayList . 我们使用Collection接口的 addAll() 方法将内容从一个列表复制到另一个列表 .
```
Arraylist arr = new Arraylist();
 arr.addAll(Arrays.asList(asset));
```
回复于 2024-04-20T19:52:31+08:00
3
如果您使用：
```
new ArrayList<T>(Arrays.asList(myArray));
```
你 may 创建 and fill 两个清单！填充两次大清单正是您不想做的事情，因为每次需要扩展容量时它会创建另一个 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
    }
    ....
}
```
危险的一面是 if you change the initial array, you change the List ! 你确定你想要吗？可能是可能不是 .

如果没有，最容易理解的方法是：
```
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 或 Guava . 但如果它没有感觉到它，那就改写另一条不优雅的路线 .
回复于 2024-04-20T19:52:31+08:00
6
正如所有人所说，这样做会
```
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");
```
回复于 2024-04-20T19:52:31+08:00
4124
您也可以使用Java 8中的流来完成 .
```
List<Element> elements = Arrays.stream(array).collect(Collectors.toList());
```
回复于 2024-04-20T19:52:31+08:00
56
```
new ArrayList<T>(Arrays.asList(myArray));
```
确保 myArray 与 T 的类型相同 . 例如，如果尝试从 int 数组创建 List<Integer> ，则会出现编译器错误 .
回复于 2024-04-20T19:52:31+08:00
82
您可以使用不同的方法转换
- 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
回复于 2024-04-20T19:52:31+08:00

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

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

会保存几个字符，如果这可能只是 List

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

回复于 2024-04-20T19:52:31+08:00

800

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

回复于 2024-04-20T19:52:31+08:00

49
另一种简单的方法是使用for-each循环将数组中的所有元素添加到新的ArrayList中 .
```
ArrayList<Element> list = new ArrayList<>();

for(Element e : array)
    list.add(e);
```
回复于 2024-04-20T19:52:31+08:00
8
每个人都已为您的问题提供了足够好的答案 . 现在从所有建议中，您需要确定哪个符合您的要求 . 您需要知道两种类型的集合 . 一个是未修改的集合，另一个是允许您稍后修改对象的集合 .

所以，这里我将举两个用例的简短示例 .
- 不可变集合创建::如果您不想在创建后修改集合对象
List<Element> elementList = Arrays.asList(array)
- 可变集合创建::当您想要在创建后修改创建的集合对象时 .
List<Element> elementList = new ArrayList<Element>(Arrays.asList(array));
回复于 2024-04-20T19:52:31+08:00

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

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

回复于 2024-04-20T19:52:31+08:00

208

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

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

回复于 2024-04-20T19:52:31+08:00

14
Java 9

在Java 9中，您可以使用List.of静态工厂方法来创建 List 文字 . 类似于以下内容：
```
List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));
```
这将返回包含三个元素的immutable列表 . 如果需要 mutable 列表，请将该列表传递给 ArrayList 构造函数：
```
new ArrayList<>(List.of(// elements vararg))
```
JEP 269：收集的便利工厂方法

JEP 269为Java Collections API提供了一些方便的工厂方法 . 这些不可变的静态工厂方法内置于Java 9及更高版本的List，Set和Map接口中 .
回复于 2024-04-20T19:52:31+08:00

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

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

回复于 2024-04-20T19:52:31+08:00

307
如果数组是原始类型，则给定的答案将不起作用 . 但是从Java 8开始，您可以使用：
```
int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());
```
回复于 2024-04-20T19:52:31+08:00

在 Java 9 中，您可以使用：

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

回复于 2024-04-20T19:52:31+08:00

3
- 如果我们看到 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));
```
注意：每个新元素（int args）将被视为单个对象并可以传递作为var-args .
- 这个问题可能还有另一个答案 .
  如果您看到 java.util.Collections.addAll() 方法的声明，您将得到如下内容：
```
public static <T> boolean addAll(Collection<? super T> c, T... a);
```
所以，这段代码也很有用
```
Collections.addAll(arraylist, array);
```
回复于 2024-04-20T19:52:31+08:00
10
To convert an array to an ArrayList, developers often do this:
```
List<String> list = Arrays.asList(arr);// this is wrong way..
```
Arrays.asList() 将返回一个 private static class inside Arrays 的ArrayList，它不是java.util.ArrayList类 . The java.util.Arrays.ArrayList 类有 set(), get(), contains() 方法，但没有任何添加元素的方法，因此其大小是固定的 . 要创建一个真正的ArrayList，您必须：
```
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));
```
ArrayList的构造函数可以接受 Collection type ，这也是 java.util.Arrays.ArrayList 的超类型
回复于 2024-04-20T19:52:31+08:00
28
这是你的元素数组 . 它可以使用此代码行转换为arraylist .

Element [] array = {new Element（1），new Element（2），new Element（3）};

ArrayListelementArray = new ArrayList（）; for（int i = 0; i
```
elementArray.add(array[i]);
```
}
回复于 2024-04-20T19:52:31+08:00

鉴于：

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

使用：

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

回复于 2024-04-20T19:52:31+08:00

17
```
new ArrayList<>(Arrays.asList(array))
```
回复于 2024-04-20T19:52:31+08:00

尽管这个问题有很多完美的书面答案，但我会添加我的输入 .

说你有 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的List表示 .

回复于 2024-04-20T19:52:31+08:00

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

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

但是最好总是使用界面：

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

回复于 2024-04-20T19:52:31+08:00

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

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

回复于 2024-04-20T19:52:31+08:00

3
（旧线程，但只有2美分，因为没有提到 Guava 或其他图书馆和其他一些细节）

如果可以的话，使用 Guava

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

用法

对于不可变列表

使用ImmutableList类及其of()和copyOf()工厂方法（元素不能为null）：
```
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 .

为何选择 Guava ？

主要的吸引力可能是减少因类型安全的泛型而造成的混乱，因为使用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 实现，但 it is NOT java.util.ArrayList . 它是一个内部类型，它模拟 ArrayList 但实际上直接引用传递的数组并使其成为"write through"（修改反映在数组中） .

它通过简单地扩展 AbstractList 禁止通过某些_99963 API的方法进行修改（因此，不支持添加或删除元素），但它允许调用 set() 来覆盖元素 . 因此，这个列表不是真正不可变的，并且应该用 Collections.unmodifiableList() 包装对 asList() 的调用 .

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

对于可变列表

与上面相同，但用实际 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);
}
```
回复于 2024-04-20T19:52:31+08:00
31
由于这个问题已经很老了，令我惊讶的是没有人提出最简单的形式：
```
List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));
```
从Java 5开始， Arrays.asList() 采用varargs参数，您不必显式构造数组 .
回复于 2024-04-20T19:52:31+08:00

从数组创建ArrayList

30 回答

更新Java 9

Java 9

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

如果可以的话，使用 Guava

用法

对于不可变列表

对于可变列表

为何选择 Guava ？

如果你不能......

对于不可变列表

对于可变列表

教育目的：良好的手工方式

相关问题