1174

如何在 Java 中将数组转换为列表?

我使用了Arrays.asList()但行为(和签名)以某种方式从 Java SE 1.4.2(文档现在存档)更改为8,并且我在网络上找到的大多数片段都使用 1.4.2 行为。

例如:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(spam)
  • on 1.4.2 返回一个包含元素 1, 2, 3 的列表
  • 在 1.5.0+ 返回一个包含数组 spam 的列表

在许多情况下,它应该很容易检测到,但有时它可能会被忽视:

Assert.assertTrue(Arrays.asList(spam).indexOf(4) == -1);
4

21 回答 21

1599

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

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

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

请参阅在 IdeOne.com 上实时运行的代码

于 2010-04-09T12:27:23.720 回答
224

在 Java 8 中,您可以使用流:

int[] spam = new int[] { 1, 2, 3 };
Arrays.stream(spam)
      .boxed()
      .collect(Collectors.toList());
于 2015-05-16T23:49:16.413 回答
154

我们不能拥有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如果我们想要eg的特定实现,ArrayList那么我们可以使用toCollection

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

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

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

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


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

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(真正的不可变列表):

我们可以使用List.ofJava 9 中引入的方法。还有其他方法:

  1. List.copyOf(Arrays.asList(integers))
  2. Arrays.stream(integers).collect(Collectors.toUnmodifiableList());
于 2015-12-23T05:07:03.127 回答
150

说到转换方式,这取决于你为什么需要你的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

于 2014-09-27T16:22:07.003 回答
126

问题是可变参数是在 Java5 中引入的,不幸的是,可变参数Arrays.asList()版本也超载了。Java5Arrays.asList(spam)编译器将其理解为 int 数组的 vararg 参数。

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

于 2010-04-09T12:26:26.107 回答
16

我最近不得不将数组转换为列表。后来程序过滤了试图删除数据的列表。当您使用 Arrays.asList(array) 函数时,您创建了一个固定大小的集合:您既不能添加也不能删除。此条目比我能更好地解释问题:为什么我在尝试从列表中删除元素时得到 UnsupportedOperationException?.

最后,我不得不进行“手动”转换:

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

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

于 2014-08-31T17:26:24.063 回答
12

更短:

List<Integer> list = Arrays.asList(1, 2, 3, 4);
于 2016-03-17T09:55:05.010 回答
8

使用数组

这是将数组转换为List. 但是,如果您尝试添加新元素或从列表中删除现有元素,UnsupportedOperationException则会抛出 an 。

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

也可以看看:

于 2017-03-04T22:12:46.583 回答
8

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

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

(无耻地从这里复制)

于 2017-11-28T23:22:50.667 回答
7

如果您使用 apache commons-lang,另一种解决方法:

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

ArrayUtils.toObject转换为_int[]Integer[]

于 2015-09-21T12:27:21.820 回答
7

单线:

List<Integer> list = Arrays.asList(new Integer[] {1, 2, 3, 4});
于 2016-03-11T04:15:46.047 回答
7

如果你的目标是 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>”。

于 2016-08-12T14:52:00.470 回答
6

你必须投入到数组中

Arrays.asList((Object[]) array)
于 2014-08-12T13:08:19.573 回答
4

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

public static <T> ArrayList<T> ArrayToArrayList(T[] array) {
    ArrayList<T> list = new ArrayList<T>();
    for(T elmt : array) list.add(elmt);
    return list;
}
于 2017-09-05T15:19:05.893 回答
4
  1. 使用番石榴:

    Integer[] array = { 1, 2, 3};
    List<Integer> list = Lists.newArrayList(sourceArray);
    
  2. 使用 Apache Commons 集合:

    Integer[] array = { 1, 2, 3};
    List<Integer> list = new ArrayList<>(6);
    CollectionUtils.addAll(list, array);
    
于 2018-04-02T13:03:33.357 回答
3

给定数组:

    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());
于 2019-09-07T19:16:21.420 回答
1

所以这取决于你正在尝试哪个 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/

于 2017-07-28T06:21:57.673 回答
1

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

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

于 2019-11-13T22:57:06.127 回答
1

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

int[] temp = {1, 2, 3, 4, 5};
List<Integer> tempList = Arrays.stream(temp).boxed().collect(Collectors.toList());
于 2021-09-23T14:28:03.327 回答
0

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

  Integer [] arr={1,2};
  List<Integer> listInt=Arrays.asList(arr);
于 2017-06-11T08:31:10.367 回答
0

使用它来将数组转换arr为列表。 Arrays.stream(arr).collect(Collectors.toList());

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

public <T> List<T> fromArrayToList(T[] a) {   
    return Arrays.stream(a).collect(Collectors.toList());
}
于 2021-07-20T08:18:09.010 回答