在Java中将数组转换为列表

在您的示例中，这是因为您不能拥有原始类型的 List 。换句话说，List<int> 是不可能的。

但是，您可以使用包装 int 原语的 Integer 类来创建 List<Integer>。使用 Arrays.asList 实用程序方法将您的数组转换为 List。

Integer[] numbers = new Integer[] { 1, 2, 3 };
List<Integer> list = Arrays.asList(numbers);

请参阅此code run live at IdeOne.com。

---

在 Java 8 中，您可以使用流：

int[] numbers = new int[] { 1, 2, 3 };
Arrays.stream(numbers)
      .boxed()
      .collect(Collectors.toList());

---

我们不能有 List<int>，因为 int 是原始类型，所以我们只能有 List<Integer>。

爪哇 16

Java 16 在 Stream API 上引入了一种名为 toList() 的新方法。这个方便的方法返回一个包含流元素的不可修改的列表。因此，尝试向列表中添加新元素只会导致 UnsupportedOperationException。

int[] ints = new int[] {1,2,3,4,5};
Arrays.stream(ints).boxed().toList();

Java 8（整数数组）

int[] ints = new int[] {1,2,3,4,5};
List<Integer> list11 =Arrays.stream(ints).boxed().collect(Collectors.toList()); 

Java 8 及更低版本（整数数组）

Integer[] integers = new Integer[] {1,2,3,4,5};
List<Integer> list21 =  Arrays.asList(integers); // returns a fixed-size list backed by the specified array.
List<Integer> list22 = new ArrayList<>(Arrays.asList(integers)); // good
List<Integer> list23 = Arrays.stream(integers).collect(Collectors.toList()); //Java 8 only

需要 ArrayList 而不是 List？

如果我们想要 List 的特定实现，例如 ArrayList，那么我们可以将 toCollection 用作：

ArrayList<Integer> list24 = Arrays.stream(integers)
                          .collect(Collectors.toCollection(ArrayList::new));

为什么不能对 list21 进行结构修改？

当我们使用 Arrays.asList 时，返回列表的大小是固定的，因为返回的列表不是 java.util.ArrayList，而是在 java.util.Arrays 中定义的私有静态类。因此，如果我们从返回的列表中添加或删除元素，则会抛出 UnsupportedOperationException。因此，当我们要修改列表时，我们应该使用 list22。如果我们有 Java8，那么我们也可以使用 list23。

需要明确的是，list21 可以在我们可以调用 list21.set(index,element) 的意义上进行修改，但这个列表可能不会在结构上进行修改，即不能从列表中添加或删除元素。您还可以查看我的这个 answer 以获得更多解释。

如果我们想要一个不可变的列表，那么我们可以将其包装为：

List<Integer> list22 = Collections.unmodifiableList(Arrays.asList(integers));

需要注意的另一点是方法 Collections.unmodifiableList 返回指定列表的不可修改视图。不可修改的视图集合是不可修改的集合，也是支持集合的视图。请注意，对支持集合的更改可能仍然是可能的，并且如果发生更改，它们将通过不可修改的视图可见。

我们可以在 Java 9 和 10 中拥有一个真正不可变的列表。

真正不可变的列表

爪哇 9：

String[] objects = {"Apple", "Ball", "Cat"};
List<String> objectList = List.of(objects);

Java 10（真正的不可变列表）：

我们可以使用 Java 9 中引入的 List.of。还有其他方式：

List.copyOf(Arrays.asList(integers)) Arrays.stream(integers).collect(Collectors.toUnmodifiableList());

---

谈到转换方式，这取决于您为什么需要您的 List。如果您只需要它来读取数据。好的，给你：

Integer[] values = { 1, 3, 7 };
List<Integer> list = Arrays.asList(values);

但是，如果你做这样的事情：

list.add(1);

你得到java.lang.UnsupportedOperationException。所以在某些情况下你甚至需要这个：

Integer[] values = { 1, 3, 7 };
List<Integer> list = new ArrayList<Integer>(Arrays.asList(values));

第一种方法实际上并不转换数组，而是像 List 一样“表示”它。但是数组具有所有属性，例如固定数量的元素。请注意，您需要在构造 ArrayList 时指定类型。

---

问题是在 Java 5 中引入了可变参数，不幸的是，Arrays.asList() 也因可变参数版本而过载。因此，Java 5 编译器将 Arrays.asList(numbers) 理解为 int 数组的 vararg 参数。

这个问题在 Effective Java 2nd Ed. 第 7 章第 42 条中有更详细的解释。

---

我最近不得不将数组转换为列表。后来程序过滤了试图删除数据的列表。当您使用 Arrays.asList(array) 函数时，您创建了一个固定大小的集合：您既不能添加也不能删除。此条目比我能更好地解释问题：Why do I get an UnsupportedOperationException when trying to remove an element from a List?。

最后，我不得不进行“手动”转换：

    List<ListItem> items = new ArrayList<ListItem>();
    for (ListItem item: itemsArray) {
        items.add(item);
    }

我想我可以使用 List.addAll(items) 操作添加从数组到列表的转换。

---

更短：

List<Integer> list = Arrays.asList(1, 2, 3, 4);

---

使用数组

这是将数组转换为 List 的最简单方法。但是，如果您尝试添加新元素或从列表中删除现有元素，则会抛出 UnsupportedOperationException。

Integer[] existingArray = {1, 2, 3};
List<Integer> list1 = Arrays.asList(existingArray);
List<Integer> list2 = Arrays.asList(1, 2, 3);

// WARNING:
list2.add(1);     // Unsupported operation!
list2.remove(1);  // Unsupported operation!

使用 ArrayList 或其他列表实现

您可以使用 for 循环将数组的所有元素添加到 List 实现中，例如 ArrayList：

List<Integer> list = new ArrayList<>();
for (int i : new int[]{1, 2, 3}) {
  list.add(i);
}

在 Java 8 中使用 Stream API

您可以将数组转换为流，然后使用不同的收集器收集流：Java 8 中的默认收集器在屏幕后面使用 ArrayList，但您也可以强加您喜欢的实现。

List<Integer> list1, list2, list3;
list1 = Stream.of(1, 2, 3).collect(Collectors.toList());
list2 = Stream.of(1, 2, 3).collect(Collectors.toCollection(ArrayList::new));
list3 = Stream.of(1, 2, 3).collect(Collectors.toCollection(LinkedList::new));

也可以看看：

为什么我们在 Java 中使用自动装箱和拆箱？

何时在 ArrayList 上使用 LinkedList？

---

在 Java 9 中，您可以通过新的便利工厂方法 List.of 获得更优雅的使用不可变列表的解决方案：

List<String> immutableList = List.of("one","two","three");

（无耻地从 here 复制）

---

单线：

List<Integer> list = Arrays.asList(new Integer[] {1, 2, 3, 4});

---

如果你的目标是 Java 8（或更高版本），你可以试试这个：

int[] numbers = new int[] {1, 2, 3, 4};
List<Integer> integers = Arrays.stream(numbers)
                        .boxed().collect(Collectors.<Integer>toList());

笔记：

注意 Collectors.<Integer>toList()，这个通用方法可以帮助您避免错误“类型不匹配：无法从 List<Object> 转换为 List<Integer>”。

---

如果您使用 Apache commons-lang，另一种解决方法：

int[] numbers = new int[] { 1, 2, 3 };
Arrays.asList(ArrayUtils.toObject(numbers));

其中 ArrayUtils.toObject 将 int[] 转换为 Integer[]

---

你必须投入到数组中

Arrays.asList((Object[]) array)

---

使用番石榴：整数 [] 数组 = { 1, 2, 3};列表<整数> 列表 = Lists.newArrayList(sourceArray);使用 Apache Commons 集合：Integer[] array = { 1, 2, 3}; List list = new ArrayList<>(6); CollectionUtils.addAll(list, array);

---

我遇到了同样的问题并编写了一个通用函数，该函数接受一个数组并返回一个具有相同内容的相同类型的 ArrayList：

public static <T> ArrayList<T> ArrayToArrayList(T[] array) {
    ArrayList<T> list = new ArrayList<T>();
    for(T elmt : array) list.add(elmt);
    return list;
}

---

给定数组：

    int[] givenArray = {2,2,3,3,4,5};

将整数数组转换为整数列表

一种方法： boxed() -> 返回 IntStream

    List<Integer> givenIntArray1 = Arrays.stream(givenArray)
                                  .boxed()
                                  .collect(Collectors.toList());

第二种方式：将流的每个元素映射到Integer，然后收集

注意：使用 mapToObj，您可以通过将每个 int 元素转换为字符串流、字符流等，方法是将 i 转换为 (char)i

    List<Integer> givenIntArray2 = Arrays.stream(givenArray)
                                         .mapToObj(i->i)
                                         .collect(Collectors.toList());

将一种数组类型转换为另一种类型示例：

List<Character> givenIntArray2 = Arrays.stream(givenArray)
                                             .mapToObj(i->(char)i)
                                             .collect(Collectors.toList());

---

所以这取决于你正在尝试哪个 Java 版本-

爪哇 7

 Arrays.asList(1, 2, 3);

或者

       final String arr[] = new String[] { "G", "E", "E", "K" };
       final List<String> initialList = new ArrayList<String>() {{
           add("C");
           add("O");
           add("D");
           add("I");
           add("N");
       }};

       // Elements of the array are appended at the end
       Collections.addAll(initialList, arr);

或者

Integer[] arr = new Integer[] { 1, 2, 3 };
Arrays.asList(arr);

在 Java 8 中

int[] num = new int[] {1, 2, 3};
List<Integer> list = Arrays.stream(num)
                        .boxed().collect(Collectors.<Integer>toList())

参考 - http://www.codingeek.com/java/how-to-convert-array-to-list-in-java/

---

请您改进这个答案，因为这是我使用的，但我不是 100% 清楚。它工作正常，但 intelliJ 添加了新的 WeatherStation[0]。为什么是 0 ？

public WeatherStation[] removeElementAtIndex(WeatherStation[] array, int index) { List list = new ArrayList(Arrays.asList(array)); list.remove(索引); return list.toArray(new WeatherStation[0]); }

---

从 Java 8 开始，应该执行以下操作

int[] temp = {1, 2, 3, 4, 5};
List<Integer> tempList = Arrays.stream(temp).boxed().collect(Collectors.toList());

---

使用它来将 Array arr 转换为 List。 Arrays.stream(arr).collect(Collectors.toList());

定义将数组转换为列表的泛型方法的示例：

public <T> List<T> fromArrayToList(T[] a) {   
    return Arrays.stream(a).collect(Collectors.toList());
}

---

使用两行代码将数组转换为列表，如果在整数值中使用它，则必须对原始数据类型使用自动装箱类型

  Integer [] arr={1,2};
  List<Integer> listInt=Arrays.asList(arr);

---

如果您正在尝试针对内存等进行优化（并且不想引入外部库），那么实现自己的不可变“数组视图列表”比您想象的要简单 – 您只需要扩展 { 1}。

class IntArrayViewList extends AbstractList<Integer> {
    int[] backingArray;
    int size;

    IntArrayViewList(int[] backingArray, int size) {
        this.backingArray = backingArray;
        this.size = size;
    }

    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int i = 0;

            @Override
            public boolean hasNext() {
                return i < size;
            }

            @Override
            public Integer next() {
                return get(i++);
            }
        };
    }

    public int size() {
        return size;
    }

    public Integer get(int i) {
        return backingArray[i];
    }
}

---