java数组变list

JAVA-数组和List转换 千次阅读
2022-03-30 16:51:38
日常开发时，经常遇到需要List与数组互相转换的场景。
List转换成数组，可以用List的toArray()或者toArray(T[] a)的方法。
数组转换成List，可以用Arrays.asList()或者Collections.addAll()方法。
如果仅仅为了打印数组，不需要把数组转换成List，
可以使用Arrays.toString()方法。

一.List转数组

List转换成数组可以调用toArray方法，可以将List直接转为Object[]数组
这里有两个重载的方法，
一般使用带泛型参数的方法：
```
Object[] toArray();
<T> T[] toArray(T[] a);
```
无参数toArray方法，这里注意不能强转,可能会出现报错.

泛型的toArray方法要注意类型必须是包装类型,基本类型是不行的.

二.数组转List

可以使用Arrays.asList()或者Collections.addAll()方法，推荐使用Collections.addAll()方法，这样得到的返回对象可以往里面添加新的元素。
```
String[] strArray = { "a", "b" };
List<String> strList = Arrays.asList(strArray);
```
注意该方法的返回值是java.util.Arrays类中一个私有静态内部类java.util.Arrays.ArrayList，
它并非java.util.ArrayList类。
java.util.Arrays.ArrayList类具有set()，get()，contains()等方法，但是不支持添加add()或删除remove()方法,调用这些方法会报错。

如果直接往返回的list添加一个新元素，运行会报错UnsupportedOperationException
```
strList.add("c");
```
解决方法是新建一个List对象，并且加入返回的strList，然后再add新元素：
```
List<String> strListNew = new ArrayList<>(strList);
strListNew.add("new data");
```
Collections.addAll():
```
String[] strArray = { "a", "b" };
List<String> strList = new ArrayList<>(strArray.length);
Collections.addAll(strList, strArray);
strListNew.add("c");
```
得到的返回对象可以直接添加新的元素。

Java8可用stream流将3种基本类型数组转为List
```
List<Integer> intList= Arrays.
stream(new int[] { 1, 2,  3}).boxed().collect(Collectors.toList());
List<Long> longList= Arrays.
stream(new long[] { 1, 2, 3 }).boxed().collect(Collectors.toList());
List<Double> doubleList= Arrays.
stream(new double[] { 1, 2, 3 }).boxed().collect(Collectors.toList());
```
```
String[] arrays = {"a", "b", "c"};
List<String> stringList= Stream.of(arrays).collect(Collectors.toList());
```
其他的数据类型short[]、byte[]、char[]在JDK1.8中目前不支持
更多相关内容
比较Java数组和各种List的性能小结
2020-09-01 18:31:44

主要是分别对Java数组、ArrayList、LinkedList和Vector进行随机访问和迭代等操作，并比较这种集合的性能。有需要的可以参考借鉴。

收起
Java编程实现数组转成list及list转数组的方法
2020-08-29 11:56:53

主要介绍了Java编程实现数组转成list及list转数组的方法,结合实例形式较为详细的总结分析了java实现数组与list之间相互转换的操作技巧,需要的朋友可以参考下

收起
Java 数组转 List 的 4 种方式
千次阅读 2021-03-23 10:52:40
本文介绍Java中数组转为List三种情况的优劣对比，以及应用场景的对比，以及程序员常犯的类型转换错误原因解析。【一】最常见方式（未必最佳）通过 Arrays.asList(strArray) 方式,将数组转换List后，不能对List增...
目录

前言
【一】最常见方式（未必最佳）
【二】数组转为List后，支持增删改查的方式
【三】通过集合工具类Collections.addAll()方法(最高效)
【四】Java8可通过stream流【推荐】
问题解答
总结
前言

本文介绍Java中数组转为List三种情况的优劣对比，以及应用场景的对比，以及程序员常犯的类型转换错误原因解析。

【一】最常见方式（未必最佳）

通过 Arrays.asList(strArray) 方式,将数组转换List后，不能对List增删，只能查改，否则抛异常。

关键代码：
List list = Arrays.asList(strArray);
```
private void testArrayCastToListError() {
  String[] strArray = new String[2];
  List list = Arrays.asList(strArray);
  //对转换后的list插入一条数据
  list.add("1");
  System.out.println(list);
}
```
执行结果：
```
Exception in thread "main" java.lang.UnsupportedOperationException
 at java.util.AbstractList.add(AbstractList.java:148)
 at java.util.AbstractList.add(AbstractList.java:108)
 at com.darwin.junit.Calculator.testArrayCastToList(Calculator.java:19)
 at com.darwin.junit.Calculator.main(Calculator.java:44)
```
程序在list.add(“1”)处，抛出异常：UnsupportedOperationException。

原因解析：
Arrays.asList(strArray)返回值是java.util.Arrays类中一个私有静态内部类java.util.Arrays.ArrayList，它并非java.util.ArrayList类。java.util.Arrays.ArrayList类具有 set()，get()，contains()等方法，但是不具有添加add()或删除remove()方法,所以调用add()方法会报错。

使用场景：
Arrays.asList(strArray)方式仅能用在将数组转换为List后，不需要增删其中的值，仅作为数据源读取使用。

【二】数组转为List后，支持增删改查的方式

通过ArrayList的构造器，将Arrays.asList(strArray)的返回值由java.util.Arrays.ArrayList转为java.util.ArrayList。

关键代码：
ArrayList<String> list = new ArrayList<String>(Arrays.asList(strArray)) ;
```
private void testArrayCastToListRight() {
  String[] strArray = new String[2];
  ArrayList<String> list = new ArrayList<String>(Arrays.asList(strArray)) ;
  list.add("1");
  System.out.println(list);
}
```
执行结果： 成功追加一个元素“1”。
```
[null, null, 1]
```
使用场景：
需要在将数组转换为List后，对List进行增删改查操作，在List的数据量不大的情况下，可以使用。

【三】通过集合工具类Collections.addAll()方法(最高效)

通过Collections.addAll(arrayList, strArray)方式转换，根据数组的长度创建一个长度相同的List，然后通过Collections.addAll()方法，将数组中的元素转为二进制，然后添加到List中，这是最高效的方法。

关键代码：
```
ArrayList< String> arrayList = new ArrayList<String>(strArray.length);
Collections.addAll(arrayList, strArray);
```
测试
```
private void testArrayCastToListEfficient(){
  String[] strArray = new String[2];
  ArrayList< String> arrayList = new ArrayList<String>(strArray.length);
  Collections.addAll(arrayList, strArray);
  arrayList.add("1");
  System.out.println(arrayList);
}
```
执行结果： 同样成功追加一个元素“1”。
```
[null, null, 1]
```
使用场景：
需要在将数组转换为List后，对List进行增删改查操作，在List的数据量巨大的情况下，优先使用，可以提高操作速度。

注：附上Collections.addAll()方法源码：
```
public static <T> boolean addAll(Collection<? super T> c, T... elements) {
   boolean result = false;
   for (T element : elements)
       result |= c.add(element);//result和c.add(element)按位或运算,然后赋值给result
   return result;
}
```
【四】Java8可通过stream流【推荐】

如果JDK版本在1.8以上，可以使用流stream来将下列3种数组快速转为List，分别是int[]、long[]、double[]，其他数据类型比如short[]、byte[]、char[]，在JDK1.8中暂不支持。由于这只是一种常用方法的封装，不再纳入一种崭新的数组转List方式，暂时算是java流送给我们的常用工具方法吧。

转换代码示例如下：
```
List<Integer> intList= Arrays.stream(new int[] { 1, 2, 3, }).boxed().collect(Collectors.toList());
List<Long> longList= Arrays.stream(new long[] { 1, 2, 3 }).boxed().collect(Collectors.toList());
List<Double> doubleList= Arrays.stream(new double[] { 1, 2, 3 }).boxed().collect(Collectors.toList());
```
如果是String数组，可以使用Stream流这样转换：
```
String[] arrays = {"tom", "jack", "kate"};
List<String> stringList= Stream.of(arrays).collect(Collectors.toList());
```
问题解答

问题： 数组类型如果是整型数组，转为List时，会报错？

答案： 在JDK1.8环境中测试，这三种转换方式是没有问题的。放心使用。对于Integer[]整型数组转List的方法和测试结果如下：
1. 方式一：不支持增删
```
Integer[] intArray1 = new Integer[2];
List<Integer> list1 = Arrays.asList(intArray1);
System.out.println(list1);
```
运行结果：
```
[null, null]
```
1. 方式二：支持增删
```
Integer[] intArray2 = new Integer[2];
List<Integer> list2 = new ArrayList<Integer>(Arrays.asList(intArray2)) ;
list2.add(2);
System.out.println(list2);
```
运行结果：
```
[null, null, 2]
```
1. 方式三：支持增删，且数据量大最高效
```
Integer[] intArray3 = new Integer[2];
List<Integer> list3 = new ArrayList<Integer>(intArray3.length);
Collections.addAll(list3, intArray3);
list3.add(3);
System.out.println(list3);
```
运行结果：
```
[null, null, 3]
```
综上，整型Integer[]数组转List<Integer>的正确方式应该是这样的。

**易错点：**可能出现的错误可能是这样转换的：
```
int[] intArray1 = new int[2];
List<Integer> list1 = Arrays.asList(intArray1);//此处报错！！！
```
报错原因：等号两边类型不一致，当然编译不通过。分析见下文。

那么在声明数组时，用int[] 还是Integer[]，哪种声明方式才能正确的转为List呢？
答案：只能用Integer[]转List<Integer>，即只能用基本数据类型的包装类型，才能直接转为List。

原因分析如下：
我们来看List在Java源码中的定义（别害怕看不懂源码，看我分析，很易懂的）：
```
public interface List<E> extends Collection<E> {省略…}
```
再来看Arrays.asList()的在Java源码定义：
```
 public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
 }
```
- 从上述源码中可以看出，List声明时，需要传递一个泛型<E>作为形参，asList()参数类型也是泛型中的通配类型<T>。Java中所有的泛型必须是引用类型。
- 什么是引用类型？Integer是引用类型，那int是什么类型？int是基本数据类型，不是引用类型。这就是为什么java中没有List<int>，而只有List<Integer>。
- 举一反三：其他8种基本数据类型byte、short、int、long、float、double、char也都不是引用类型，所以8种基本数据类型都不能作为List的形参。但String、数组、class、interface是引用类型，都可以作为List的形参，所以存在List<Runnable>接口类型的集合、List<int[]>数组类型的集合、List<String>类的集合。但不存在List<byte>、List<short> 等基本类型的集合。
有了上述基础知识后，再来看为什么下面两行代码第二行能编译通过，第三行却编译报错？
```
int[] intArray1 = new int[1]; 
Arrays.asList(intArray1);//编译不报错
List<Integer> list1 = Arrays.asList( intArray1);//编译报错
```
答案：
- 第二行代码，Arrays.asList()方法的入参是个引用类型的int[],那么返回值类型一定是List<int[]> ,其完整代码是：List<int[]> intsArray = Arrays.asList(intArray1);，所以编译通过，没问题。
- 第三行报错，因为等号两边的类型不一致，左边：List<Integer>,右边List<int[]>，所以编译时就报错。
总结

现在你应该明白，为什么int[]不能直接转换为List<Integer>，而Integer[]就可以转换为List<Integer>了吧。因为List中的泛型必须是引用类型，int是基本数据类型，不是引用类型，但int的包装类型Integer是class类型，属于引用类型，所以Integer可以作为List形参，List<Integer>在java中是可以存在的，但不存在List<int>类型。

在编码时，我们不光要知其然，还要知其所以然，通过分析JDK源码，才能得出一手信息，不仅了解到了如何用，还能得出为何这样用。
收起
展开全文
Java中数组转List的三种方法与对比分析
2020-08-27 06:19:05

主要给大家介绍了关于Java中数组转List的三种方法与对比分析的相关资料，分别介绍了最常见方式、数组转为List后，支持增删改查的方式以及通过集合工具类Collections.addAll()方法，需要的朋友可以参考下

收起
Java数组转List的三种方式及对比
万次阅读 多人点赞 2018-03-18 00:10:04
本文介绍Java中数组转为List三种情况的优劣对比，以及应用场景的对比，以及程序员常犯的类型转换错误原因解析。
前言：

本文介绍Java中数组转为List三种情况的优劣对比，以及应用场景的对比，以及程序员常犯的类型转换错误原因解析。

一.最常见方式（未必最佳）

通过 Arrays.asList(strArray) 方式,将数组转换List后，不能对List增删，只能查改，否则抛异常。

关键代码：List list = Arrays.asList(strArray);
```
private void testArrayCastToListError() {
		String[] strArray = new String[2];
		List list = Arrays.asList(strArray);
		//对转换后的list插入一条数据
		list.add("1");
		System.out.println(list);
	}
```
执行结果：
```
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.AbstractList.add(AbstractList.java:148)
	at java.util.AbstractList.add(AbstractList.java:108)
	at com.darwin.junit.Calculator.testArrayCastToList(Calculator.java:19)
	at com.darwin.junit.Calculator.main(Calculator.java:44)
```
程序在list.add(“1”)处，抛出异常：UnsupportedOperationException。

原因解析：
Arrays.asList(strArray)返回值是java.util.Arrays类中一个私有静态内部类java.util.Arrays.ArrayList，它并非java.util.ArrayList类。java.util.Arrays.ArrayList类具有 set()，get()，contains()等方法，但是不具有添加add()或删除remove()方法,所以调用add()方法会报错。

使用场景：Arrays.asList(strArray)方式仅能用在将数组转换为List后，不需要增删其中的值，仅作为数据源读取使用。

二.数组转为List后，支持增删改查的方式

通过ArrayList的构造器，将Arrays.asList(strArray)的返回值由java.util.Arrays.ArrayList转为java.util.ArrayList。

关键代码：ArrayList<String> list = new ArrayList<String>(Arrays.asList(strArray)) ;
```
private void testArrayCastToListRight() {
		String[] strArray = new String[2];
		ArrayList<String> list = new ArrayList<String>(Arrays.asList(strArray)) ;
		list.add("1");
		System.out.println(list);
	}
```
执行结果：成功追加一个元素“1”。
```
[null, null, 1]
```
使用场景：需要在将数组转换为List后，对List进行增删改查操作，在List的数据量不大的情况下，可以使用。

三.通过集合工具类Collections.addAll()方法(最高效)

通过Collections.addAll(arrayList, strArray)方式转换，根据数组的长度创建一个长度相同的List，然后通过Collections.addAll()方法，将数组中的元素转为二进制，然后添加到List中，这是最高效的方法。

关键代码：
```
ArrayList< String> arrayList = new ArrayList<String>(strArray.length);
Collections.addAll(arrayList, strArray);
```
测试：
```
private void testArrayCastToListEfficient(){
		String[] strArray = new String[2];
		ArrayList< String> arrayList = new ArrayList<String>(strArray.length);
		Collections.addAll(arrayList, strArray);
		arrayList.add("1");
		System.out.println(arrayList);
	}
```
执行结果：同样成功追加一个元素“1”。
```
[null, null, 1]
```
使用场景：需要在将数组转换为List后，对List进行增删改查操作，在List的数据量巨大的情况下，优先使用，可以提高操作速度。

注：附上Collections.addAll()方法源码：
```
public static <T> boolean addAll(Collection<? super T> c, T... elements) {
        boolean result = false;
        for (T element : elements)
            result |= c.add(element);//result和c.add(element)按位或运算,然后赋值给result
        return result;
    }
```
四.Java8可通过stream流将3种基本类型数组转为List

如果JDK版本在1.8以上，可以使用流stream来将下列3种数组快速转为List，分别是int[]、long[]、double[]，其他数据类型比如short[]、byte[]、char[]，在JDK1.8中暂不支持。由于这只是一种常用方法的封装，不再纳入一种崭新的数组转List方式，暂时算是java流送给我们的常用工具方法吧。

转换代码示例如下：
```
List<Integer> intList= Arrays.stream(new int[] { 1, 2, 3, }).boxed().collect(Collectors.toList());
List<Long> longList= Arrays.stream(new long[] { 1, 2, 3 }).boxed().collect(Collectors.toList());
List<Double> doubleList= Arrays.stream(new double[] { 1, 2, 3 }).boxed().collect(Collectors.toList());
```
如果是String数组，可以使用Stream流这样转换：
```
String[] arrays = {"tom", "jack", "kate"};
List<String> stringList= Stream.of(arrays).collect(Collectors.toList());
```
--------------------------------------正文结束，以下是对评论中的问题集中回复和讲解--------------------------------------

补充：回答评论中的疑问

问题： 有评论提出：数组类型如果是整型数组，转为List时，会报错？

答案： 在JDK1.8环境中测试，这三种转换方式是没有问题的。放心使用。对于Integer[]整型数组转List的方法和测试结果如下：
1. 方式一：不支持增删
```
Integer[] intArray1 = new Integer[2];
List<Integer> list1 = Arrays.asList(intArray1);
System.out.println(list1);
```
运行结果：
```
[null, null]
```
1. 方式二：支持增删
```
Integer[] intArray2 = new Integer[2];
List<Integer> list2 = new ArrayList<Integer>(Arrays.asList(intArray2)) ;
list2.add(2);
System.out.println(list2);
```
运行结果：
```
[null, null, 2]
```
1. 方式三：支持增删，且数据量大最高效
```
Integer[] intArray3 = new Integer[2];
List<Integer> list3 = new ArrayList<Integer>(intArray3.length);
Collections.addAll(list3, intArray3);
list3.add(3);
System.out.println(list3);
```
运行结果：
```
[null, null, 3]
```
综上，整型Integer[]数组转List<Integer>的正确方式应该是这样的。

猜想你们遇到的问题： 由于评论没有给出报错的代码，所以我猜想你们出现的错误可能是这样转换的：
```
int[] intArray1 = new int[2];
List<Integer> list1 = Arrays.asList(intArray1);//此处报错！！！
```
报错原因：等号两边类型不一致，当然编译不通过。分析见下文。

那么在声明数组时，用int[] 还是Integer[]，哪种声明方式才能正确的转为List呢？
答案： 只能用Integer[]转List<Integer>，即只能用基本数据类型的包装类型，才能直接转为List。

原因分析如下：

我们来看List在Java源码中的定义（别害怕看不懂源码，看我分析，很易懂的）：
```
public interface List<E> extends Collection<E> {省略…}
```
再来看Arrays.asList()的在Java源码定义：
```
 public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }
```
- 从上述源码中可以看出，List声明时，需要传递一个泛型<E>作为形参，asList()参数类型也是泛型中的通配类型<T>。Java中所有的泛型必须是引用类型。
- 什么是引用类型？Integer是引用类型，那int是什么类型？int是基本数据类型，不是引用类型。这就是为什么java中没有List<int>，而只有List<Integer>。
- 举一反三：其他8种基本数据类型byte、short、int、long、float、double、char也都不是引用类型，所以8种基本数据类型都不能作为List的形参。但String、数组、class、interface是引用类型，都可以作为List的形参，所以存在List<Runnable>接口类型的集合、List<int[]>数组类型的集合、List<String>类的集合。但不存在list<byte>、list<short> 等基本类型的集合。
有了上述基础知识后，再来看为什么下面两行代码第二行能编译通过，第三行却编译报错？
```
int[] intArray1 = new int[1]; 
Arrays.asList(intArray1);//编译不报错
List<Integer> list1 = Arrays.asList( intArray1);//编译报错
```
答案：
- 第二行代码，Arrays.asList()方法的入参是个引用类型的int[],那么返回值类型一定是List<int[]> ,其完整代码是：List<int[]> intsArray = Arrays.asList(intArray1);，所以编译通过，没问题。
- 第三行报错，因为等号两边的类型不一致，左边：List<Integer>,右边List<int[]>，所以编译时就报错。
总结

现在你应该明白，为什么int[]不能直接转换为List<Integer>，而Integer[]就可以转换为List<Integer>了吧。因为List中的泛型必须是引用类型，int是基本数据类型，不是引用类型，但int的包装类型Integer是class类型，属于引用类型，所以Integer可以作为List形参，List<Integer>在java中是可以存在的，但不存在List<int>类型。

在编码时，我们不光要知其然，还要知其所以然，通过分析JDK源码，才能得出一手信息，不仅了解到了如何用，还能得出为何这样用。

希望我的解答对你有帮助，有疑惑的地方，可以在文章下方评论，我会给大家解惑的，喜欢本文请点赞和收藏。
收起
展开全文
java 数组
Java 数组转List的四种方式
千次阅读 2021-09-04 21:39:56
Java 数组转List的四种方式第一种方式(未必最佳):使用ArrayList.asList(strArray) 使用Arrays工具类Arrays.asList(strArray)方式,转换完成后,只能对List数组进行查改,不能增删,增删就会抛出...
Java 数组转List的四种方式

第一种方式(未必最佳):使用ArrayList.asList(strArray)

使用Arrays工具类Arrays.asList(strArray)方式,转换完成后,只能对List数组进行查改,不能增删,增删就会抛出UnsupportedOperationException 异常
```
import java.util.Arrays;
import java.util.List; 
public static void Demo1() {
        String[] str = {"fgx", "lzy"};
        //注意这个List不是Collections包内的List,而是util包里面的List接口
        List<String> ints = Arrays.asList(str);
    	//这里会报错
        ints.add("laopo");
    }
```
添加数据报错:
```
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.AbstractList.add(AbstractList.java:148)
	at java.util.AbstractList.add(AbstractList.java:108)
	at JAVA基础.JDK8新特性.Java数组转List.Demo1(Java数组转List.java:20)
	at JAVA基础.JDK8新特性.Java数组转List.main(Java数组转List.java:13)
```
报错原因:Arrays.asList(str)返回值是java.util.Arrays类中一个私有静态内部类 java.utiil.Arrays.Arraylist,并不是我们平时用的java.util.ArrayList();

使用场景:Arrays.asList(strArray)方式仅能用在将数组转换为List后，不需要增删其中的值，仅作为数据源读取使用。

第二种方法(支持增删查改):

通过ArrayList的构造器,将Arrays.asList(strArray)的返回值由java.utilArrays.ArrayList转为java.util.ArrayList.

关键代码：ArrayList list = new ArrayList(Arrays.asList(strArray)) ;
```
  String[] str = {"fgx", "lzy"};
        //注意这个List不是Collections包内的List,而是util包里面的List接口
        java.util.ArrayList<String> strings = new ArrayList<>(Arrays.asList(str));
        strings.add("aop");
        strings.stream().forEach(System.out::println);
```
使用场景:需要在将数组转换为List后，对List进行增删改查操作，在List的数据量不大的情况下，可以使用。

第三种方式(通过集合工具类Collections.addAll()方法(最高效))

通过Collections.addAll(arrayList, strArray)方式转换，根据数组的长度创建一个长度相同的List，然后通过Collections.addAll()方法，将数组中的元素转为二进制，然后添加到List中，这是最高效的方法。
```
 public static void Demo3() {
        //注意这个List不是Collections包内的List,而是util包里面的List接口
        String[] str = {"fgx", "lzy"};
        java.util.ArrayList<String> stringList = new ArrayList<>(str.length);
        Collections.addAll(stringList,str);
    }
```
第四种方式通过JDK8的Stream流将3总基本类型数组转为List

如果JDK版本在1.8以上,使用流stream来将下列3种数组快速转为List,分别是int[],long[],double[],不支持short[ ],byte[ ],char[]在JDK1.8中暂不支持.
```
 int[] ints = {2, 34, 55, 22, 11};
        long[] longs = {1, 2, 3};
        double[] doubles = {1, 2, 3};
        Arrays.stream(ints).boxed().collect(Collectors.toList());
        Arrays.stream(longs).boxed().collect(Collectors.toList());
        Arrays.stream(doubles).boxed().collect(Collectors.toList());
```
TIPs:为什么int[]不能直接转为List,而Integer[]可以转为List,而Integer[]就可以转为List了,因为List中的泛型必须是引用类型。
收起
展开全文
浅谈java 字符串,字符数组,list间的转化
2020-09-01 06:47:55

下面小编就为大家带来一篇浅谈java 字符串,字符数组,list间的转化。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧

收起
Java 数组转List的几种方法
千次阅读 2021-06-11 16:02:06

Java 数组转List的几种方法一、Arrays.asList二、Collections.addAll三、Arrays.stream(arr).collect(Collectors.toList()) 本文提供了几种Java中常用的数组转List的方法一、Arrays.asList // Array 转 List String...

收起
Java中数组与List的区别
千次阅读 2022-02-08 12:13:37

① 数组声明的时候要指定数组的大小，用基本类型。 ② List接口是一个有序的 Collection，没有固定大小的限制。其声明时用基本类型需要用其引用类型（List<E> list = new ArrayList<>(); 这里的E指的是...

收起
Java int数组转List
2022-01-23 21:46:27

Java数组和集合LIst互转

收起
java数组和list的转换
千次阅读 2018-09-08 21:45:19

asList() 把数组转换成集合时，不能使用其修改集合相关的方法，它的 add / remove / clear 方法会抛出 UnsupportedOperationException 异常。说明： asList 的返回对象是一个 Arrays 内部类，并没有实现集合的...

收起
Java数组与内存控制
2018-09-20 10:07:59

Java数组在内存分配方面的知识；Java数组的静态特征；对于数组变量而言，一定要区分它何时是数组变量，何时代表数组对象本身。

收起
java中数组转List
千次阅读 2019-07-08 01:00:21

1.java jdk 提供的Arrays.asList(T... a)方法 public static void main(String[] args) { String[] strArray = {"a","b","c"}; List<String> strList = Arrays.asList(strArray); Sy...

收起

开发语言
java中数组与List相互转换的方法
千次阅读 2021-02-28 14:58:04

1.List转换成为数组。(这里的List是实体是ArrayList)调用ArrayList的toArray方法。toArraypublic T[] toArray(T[] a)返回一个按照正确的顺序包含此列表中所有元素的数组；返回数组的运行时类型就是指定数组的运行时...

收起
java中将数组转为list集合的方法
千次阅读 2021-03-11 11:03:45

java中将数组转为list集合的方法发布时间：2020-10-28 09:42:15来源：亿速云阅读：98作者：小新小编给大家分享一下java中将数组转为list集合的方法，希望大家阅读完这篇文章后大所收获，下面让我们一起去探讨吧！...

收起
Java List转换成String数组几种实现方式详解
2020-08-31 19:41:11

主要介绍了Java List转换成String数组几种实现方式详解的相关资料,需要的朋友可以参考下

收起
老程序员Java数组转List都这样操作
千次阅读 2021-11-13 15:08:25

通过 Arrays.asList(strArray) 方式,将数组转换List后，不能对List增删，只能查改，否则抛异常。测试代码如下： public static void way1(){ List<String> list = Arrays.asList("1", "2"); //对转换后的...

收起

开发语言
Java 字符串数组转换为List数组
千次阅读 2021-03-16 00:26:31

public class Test {public static void main(String[] args) {String[] animals = {"dog","cat","rabbit","fish...List animalList = Arrays.asList(animals);for(String str : animalList){System.out.println(str...

收起
Java——数组转换为List集合
千次阅读 2019-01-10 15:25:38

package day04; import java.util.ArrayList; import java.util.... * 数组转换为List集合 * 不能转换为Set集合，原因在于Set集合不能存放重复元素 * @author Administrator * */ public class ToListDemo ...

收起
Java中将数组转成List
千次阅读 2021-01-18 22:52:25

在开发中，我们有时候会需要将数组转换为集合List，这时候可能会想到Arrays.asList()，毕竟它是java提供的，肯定专业。。。吗？ Integer[] a = {1, 2, 3}; List<Integer> list = Arrays.asList(a); System.out...

收起
java 数组、List、Set互相转化
千次阅读 2021-01-28 15:05:05

1String数组转化成List //准备一个String数组 String[] strs = {"aa","bb","cc"}; //String数组转List List<String> strsToList2=new ArrayList<>(); 2 List转化成String数组 //先准备一个List ...

收起
Java> List与数组之间相互转换
千次阅读 2021-02-28 15:22:03

List与数组之间如何相互转行呢？数组转List1. 利用遍历数组每个元素，将元素一个个加入List最通用的方法，适合任意基本元素类型和语言。示例：List list = new ArrayList<>();int[] a = new int[]{3,8,20,7,11...

收起
Java 数组、List初始化赋值
千次阅读 2021-04-15 19:38:12

1 数组初始化赋值 //第一种初始化赋值方式 String[] strs1={"1","2"}; //第二种初始化赋值方式 String[] strs2=new String[]{"1","2"}; 2 List初始化赋值 //第一种初始化赋值方式(推荐) List<String> ...

收起
java中数组list map三者之间的互转介绍
2020-09-04 22:32:03

java中数组 list map之间的互转一张图清晰呈现并附有代码，不懂的朋友可以参考下

收起
Java 数组ArrayList语法
千次阅读 2021-02-12 11:10:37

2.定义数组listArrayList list = new ArrayList(); 不能是基本类型，必须是类3.获取集合大小size()4.存入数据add(Object object);从下标0开始加入add(int idx,Object object);将object插入索引为idx的位置...

收起
java数组 如何动态增加、查询、删除元素
千次阅读 2022-04-21 14:20:59

一般数组是不能添加元素的，因为数组在初始化时就已定好长度了，不能改变长度。怎么动态则增加数组元素呢？使用ArrayList<类型> list = new ArrayList<>(); 一、定义但是其中的类型不能为基本...

收起
JAVA得到数组中最大值和最小值的简单实例
2020-09-04 06:22:02

主要介绍了JAVA得到数组中最大值和最小值的简单实例,需要的朋友可以参考下

收起
JAVA中list,set,数组之间的转换详解
2020-09-05 01:50:40

以下是对JAVA中list,set,数组之间的转换进行了详细的分析介绍，需要的朋友可以过来参考下

收起

比较Java数组和各种List的性能小结

Java编程实现数组转成list及list转数组的方法

Java 数组转 List 的 4 种方式

目录

前言

【一】最常见方式（未必最佳）

【二】数组转为List后，支持增删改查的方式

【三】通过集合工具类Collections.addAll()方法(最高效)

【四】Java8可通过stream流 【推荐】

问题解答

总结

Java中数组转List的三种方法与对比分析

Java数组转List的三种方式及对比

前言：

一.最常见方式（未必最佳）

二.数组转为List后，支持增删改查的方式

三.通过集合工具类Collections.addAll()方法(最高效)

四.Java8可通过stream流将3种基本类型数组转为List

补充：回答评论中的疑问

总结

Java 数组转List的四种方式

Java 数组转List的四种方式

第一种方式(未必最佳):使用ArrayList.asList(strArray)

第二种方法(支持增删查改):

第三种方式(通过集合工具类Collections.addAll()方法(最高效))

第四种方式通过JDK8的Stream流将3总基本类型数组转为List

浅谈java 字符串,字符数组,list间的转化

Java 数组转List的几种方法

Java中数组与List的区别

Java int数组转List

java数组和list的转换

Java数组与内存控制

java中数组转List

java中数组与List相互转换的方法

java中将数组转为list集合的方法

Java List转换成String数组几种实现方式详解

老程序员Java数组转List都这样操作

Java 字符串数组转换为List数组

Java——数组转换为List集合

Java中将数组转成List

java 数组、List、Set互相转化

Java> List与数组之间相互转换

Java 数组、List初始化赋值

java中数组list map三者之间的互转介绍

Java 数组ArrayList语法

java数组 如何动态增加、查询、删除元素

JAVA得到数组中最大值和最小值的简单实例

JAVA中list,set,数组之间的转换详解

java数组变list

【四】Java8可通过stream流【推荐】

四.Java8可通过`stream`流将3种基本类型数组转为List

java数组如何动态增加、查询、删除元素