前言：
本文介绍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的方法和测试结果如下：
方式一：不支持增删
Integer[] intArray1 = new Integer[2];
List<Integer> list1 = Arrays.asList(intArray1);
System.out.println(list1);

运行结果：
[null, null]

方式二：支持增删
Integer[] intArray2 = new Integer[2];
List<Integer> list2 = new ArrayList<Integer>(Arrays.asList(intArray2)) ;
list2.add(2);
System.out.println(list2);

运行结果：
[null, null, 2]

方式三：支持增删，且数据量大最高效
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源码，才能得出一手信息，不仅了解到了如何用，还能得出为何这样用。
希望我的解答对你有帮助，有疑惑的地方，可以在文章下方评论，我会给大家解惑的，喜欢本文请点赞和收藏。

List<String> tbList = Arrays.asList(result.getTb_name().split(","));

 

不曾想到，“Java数组转List”竟然有这么多的学问，震撼之余夹带些许不堪。关于“Java数组转List”其实是非常基础的知识，况且有很多人在博客中均有所讨论，难免让我觉得写这样的讨论文章显得多少没有必要！转念想到“不积硅步，无以成千里”，于是强迫自己再次对该问题做一些深层次的实践。



一、Create ArrayList from array

Create ArrayList from array在stackoverflow上引发的讨论之热烈程度多少让我感到吃惊：

new ArrayList(Arrays.asList(array))
List list = Arrays.asList(array);
Use Guava ——Lists.newArrayList(aStringArray); 
Collections.addAll(arraylist, array);
for(Element e : array) —— list.add(e);
从里面可以提取出以上五种的方案，关于Guava的，由于我对此不甚了解，所以暂时放过，那么剩余四种情况，我们就详细来做实践。



①、new ArrayList(Arrays.asList(array))

其实我觉得第一种方案，挺简洁好使的。



String[] array1 = { new String("1"), new String("2"), new String("3") };

arrayList = new ArrayList<String>(Arrays.asList(array1));

for (String s : arrayList) {
    System.out.print(s + "、");
}

try {
    arrayList.add("111");

    for (String s : arrayList) {
        System.out.print(s + "、");
    }
} catch (Exception e) {
    System.out.print(e);
}

try {
    array[1] = "qw";

    for (String s : arrayList) {
        System.out.print(s + "、");
    }
} catch (Exception e) {
    System.out.print(e);
}

System.out.println();
System.out.println("----------new ArrayList<String>(Arrays.asList(array1))---------------");

输出内容如下：


  
1、2、3、1、2、3、111、1、2、3、111、 

  ———-new ArrayList(Arrays.asList(array1))—————


但是，看完stackoverflow上的讨论，觉得这种方案确实有最大的弊端！


  
you may create and fill two lists ! 


好吧，这个过程会产生两个list，真让人操碎了心啊！不过请注意，该种方法与第二种方法之间多了一个“new ArrayList”，那么为什么要再new一次呢？请看第二种方法的介绍！



②、List list = Arrays.asList(array)

从java的API中我们可以看出


  
asList 

  public static  List asList(T… a)返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直接写”到数组。）此方法同 Collection.toArray() 一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，并且实现了 RandomAccess。  

  此方法还提供了一个创建固定长度的列表的便捷方法，该列表被初始化为包含多个元素： 

 List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

  
  
参数： 

  a - 支持列表的数组。  

  返回： 

  指定数组的列表视图。


此方法会有两个弊端：

list长度固定，也就是说无法进行add元素。
对返回列表的更改会“直接写”到数组。
我们接着看例子：



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

List<String> arrayList = Arrays.asList(array);

for (String s : arrayList) {
    System.out.print(s + "、");
}

try {
    arrayList.add("111");

    for (String s : arrayList) {
        System.out.print(s + "、");
    }
} catch (Exception e) {
    System.out.print(e);
}

try {
    arrayList.set(1, "qw");

    for (String s : array) {
        System.out.print(s + "、");
    }
} catch (Exception e) {
    System.out.print(e);
}

System.out.println();
System.out.println("----------Arrays.asList---------------");

输出结果如下：


  
1、2、3、java.lang.UnsupportedOperationException1、qw、3、 

  ———-Arrays.asList—————


从结果中可以证明：


  
This will work fine. But some caveats:
  
  
The list returned from asList has fixed size. So, if you want to be able to add or remove elements from the returned list in your code, you’ll need to wrap it in a new ArrayList. Otherwise you’ll get an UnsupportedOperationException.
  
The list returned from asList() is backed by the original array. If you modify the original array, the list will be modified as well. This may be surprising.
  

所以该种“数组转换为List”的做法局限很多，限制了转换后List的使用！

那么再回到第一种方法“new ArrayList(Arrays.asList(array))”上，使用new ArrayList显然规避了以上两种限制，但同时创建了两个list，所以以上两种方法虽然在代码量上足够简洁，但弊端同样很多，也就是说这两种方法多少有点“后遗症”。



④、Collections.addAll(arraylist, array);

跳过Guava，我们来看“Collections.addAll(arraylist, array)”。



String[] array2 = { new String("1"), new String("2"), new String("3") };

arrayList = new ArrayList<String>();
Collections.addAll(arrayList, array2);

for (String s : arrayList) {
    System.out.print(s + "、");
}

try {
    arrayList.add("111");

    for (String s : arrayList) {
        System.out.print(s + "、");
    }
} catch (Exception e) {
    System.out.print(e);
}

try {
    array[1] = "qw";

    for (String s : arrayList) {
        System.out.print(s + "、");
    }
} catch (Exception e) {
    System.out.print(e);
}

System.out.println();
System.out.println("-------------Collections.addAll(arrayList, array2)------------");

对于第四种方法，我觉得还不错，代码也足够的简洁，且没有多余的“后遗症”，所以推荐这种做法！

另外，通过api可以看到如下解释：


  
public static  boolean addAll(Collection< ? super T> c,T… elements)
  
  
将所有指定元素添加到指定 collection 中。可以分别指定要添加的元素，或者将它们指定为一个数组。此便捷方法的行为与 c.addAll(Arrays.asList(elements)) 的行为是相同的，但在大多数实现下，此方法运行起来可能要快得多。 
  
  
在分别指定元素时，此方法提供了将少数元素添加到现有 collection 中的一个便捷方式：  

  Collections.addAll(flavors, “Peaches ‘n Plutonium”, “Rocky Racoon”);


该方式对应还有另外一种写法



String[] array3 = { new String("1"), new String("2"), new String("3") };

ArrayList<String> arrayList3 = new ArrayList<String>();
arrayList3.addAll(Arrays.asList(array3));

这种写法就不如Collections.addAll！



⑤、for(Element e : array) —— list.add(e);

其实，很多时候我们忽略了最原始的写法，也就是所谓的



arrayList3 = new ArrayList<String>();
for (String s : array3) {
    arrayList3.add(s);
}

这种写法在我看来，也足够的简洁，同样没有后遗症，并且运行速度，我想，肯定不慢！

总结完上述“Java数组转换为List”方法后，真心感觉原来基础知识也这么有深度，赶紧学起来吧！


  
感谢您阅读【沉默王二的博客】，如果王二的博客给您带来一丝帮助或感动，我（也就是王二）将不甚荣幸。 

  如果您碰巧喜欢，可以留言或者私信我，这将是我鼓捣更多优秀文章的最强动力。

public class JUnitTest {
    /**
     * Java数组转List集合
     */
    public void javaArrayToList() {
        String[] strArray = {"1", "2", "3"};
        List<String> stringList = new ArrayList<>();
        for (String str : strArray) {//这个直接循环数组赋值到集合中
            stringList.add(str);
        }
        //此方法只要是继承了Collection接口就可以使用
        Collections.addAll(stringList, strArray);
        System.out.println("stringList = " + stringList);
        //此方法需要引用 com.google.guava包
        stringList = Lists.newArrayList(strArray);
        System.out.println("stringList = " + stringList);
        //此方法转换的集合无法进行增加或者移除
        stringList = Arrays.asList(strArray);
        System.out.println("stringList = " + stringList);
    }
 
}