精华内容
下载资源
问答
  • 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的包装类型Integerclass类型,属于引用类型,所以Integer可以作为List形参,List<Integer>在java中是可以存在的,但不存在List<int>类型。

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

    希望我的解答对你有帮助,有疑惑的地方,可以在文章下方评论,我会给大家解惑的,喜欢本文请点赞和收藏。

    展开全文
  • Java 数组转list

    万次阅读 2018-12-11 20:13:45
    List&lt;String&gt; tbList = Arrays.asList(result.getTb_name().split(","));  
    List<String> tbList = Arrays.asList(result.getTb_name().split(","));

     

    展开全文
  • * Java数组转List集合 */ public void javaArrayToList() { //1、首先是循环方式 String[] strArray = {"1", "2", "3"}; List<String> stringList = new ArrayList<>(); //循环完毕后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);
        }
     
    }
    
    展开全文
  • 不曾想到,“Java数组转List”竟然有这么多的学问,震撼之余夹带些许不堪。

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

    一、Create ArrayList from array

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

    1. new ArrayList(Arrays.asList(array))
    2. List list = Arrays.asList(array);
    3. Use Guava ——Lists.newArrayList(aStringArray);
    4. Collections.addAll(arraylist, array);
    5. 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 - 支持列表的数组。
    返回:
    指定数组的列表视图。

    此方法会有两个弊端:

    1. list长度固定,也就是说无法进行add元素。
    2. 对返回列表的更改会“直接写”到数组。

    我们接着看例子:

    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:

    1. 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.
    2. 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”方法后,真心感觉原来基础知识也这么有深度,赶紧学起来吧!


    感谢您阅读【沉默王二的博客】,如果王二的博客给您带来一丝帮助或感动,我(也就是王二)将不甚荣幸。
    如果您碰巧喜欢,可以留言或者私信我,这将是我鼓捣更多优秀文章的最强动力。

    展开全文
  • java数组转list误区

    千次阅读 2018-05-13 11:04:09
    ava中数组转list使用Arrays.asList(T... a)方法。示例: public class App { public static void main(String[] args) { List&lt;String&gt; stringA = Arrays.asList("hello", "...
  • 最近开发中,业务上处理,经常用到asList方法,这让我不...大家都知道这个方法是将数组转list,是JDK中java.util包中Arrays类的静态方法。大家使用时一定要注意(请看代码和注释,一看就明了了):  String s[]...
  • Java 数组转成集合List 三种方法 package com.list; import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * Java 数组转成集合List * @author luolei * @date 2019年2月18日 ...
  • Java int数组转List<Integer>

    千次阅读 2020-03-22 12:47:03
    Java int数组转ListJava中将int数组转为List时如果使用Arrays.asList()方法将生成一个List<int[]>。 此时我们可以使用Java8的stream流方法进行转换 int[] ints = {1,2,3}; List<Integer> list = ...
  • java数组转listlist转数组

    千次阅读 2017-08-21 11:33:20
    数组转list:String[] strArray = new String[] { "a", "b" }; List<String> list = Arrays.asList(strArray);注意: 使用工具类 Arrays.asList()把数组转换成list时,不能使用其修改集合相关的方法,它的 add/...
  • java数组list的转换

    千次阅读 2018-09-08 21:45:19
    asList() 把数组转换成集合时,不能使用其修改集合相关的方法,它的 add / remove / clear 方法会抛出 UnsupportedOperationException 异常。 说明: asList 的返回对象是一个 Arrays 内部类,并没有实现集合的...
  • 以下是Object转List的需求场景 前端通过http请求,body以json形式,内容含有字符串、数组。 后端使用Map<string,Object>的方式接收,些时如何将部分的Object转换成List 此时,如何将数组参数Object转换成List...
  • 1 数组转换为List 调用Arrays类的静态方法asList。 String[] arr = new String[] {"str1", "str2"}; List listSpecial = Arrays.asList(arr); 2 List转换为数组 这里的List以ArrayList为例,ArrayList的API提供了...
  • java 数组List转换

    2012-05-17 11:42:03
    数组->List Arrays.asList()   List->数组 Collections.asArray()
  • java数组转list

    千次阅读 2019-05-08 19:44:18
    package com.kai.lamada; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; public class demo1 { public static void main(String[] args) { ...
  • 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方法

    千次阅读 2016-04-01 15:15:01
    1.List转换成为数组。(这里的List是实体是ArrayList) List list = new ArrayList(); list.add("1"); list.add("2"); final int size = list.size(); String[] arr = (String[])list.toArray(new String[size]); 2...
  • Java-list转数组、数组转list

    千次阅读 2019-03-24 18:02:16
    //list转数组 List<String> pfIdsList = new ArrayList<String>(); String[] PFIdArr = pfIdsList.toArray(new String[pfIdsList.size...//数组转list String[] s = {"a","b","c"}; List list = java.ut...
  • 今天在开发中遇到对String[]与List两者之间相互转换的问题,由于java没怎么系统的学,所以不了解这两者之间的转化方法。 求知度娘后,总结如下: 1、数组转换为List 调用Arrays类的静态方法asList String[] ...
  • Java数组/List集合 JSON 字符串

    千次阅读 2019-07-09 16:31:04
    1. 导入fastjson依赖 2.转换代码 public class Test { public static void main... 需求: 将product数组(List) 成 JSON 字符串 业务场景: 数据库查出的数据,经过数据分类处理后得到List/Arr,需要到前端Ec...
  • JavaList转换为数组,数组转List

    千次阅读 热门讨论 2020-12-11 13:20:34
    List转换为Array可以这样处理: ArrayList<String> list=new ArrayList<String>(); String[] strings = new String...反过来,将数组转List如下: String[] s = {"a","b","c"}; List list = java.u.
  • 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,List转ArrayList等操作学习java字符串分割为数组数组转List集合判断list中是否包含某元素如果List集合包含某元素,则删除该元素 java字符串分割为数组 定义字符串String str = ...
  • Java8 stream数组转List

    千次阅读 2019-05-04 20:26:56
    String[] arr = {“a”, “b”, “c”}; List list = Stream.of(arr).collect(Collectors.toList());
  • Java8数组List相互转换

    万次阅读 2016-11-28 15:00:11
    使用Java 1.8中的循环转换数组List,代码: private List arrayToList(T[] objects) { return Stream.of(objects).map(object -> { return object; }).collect(Collectors.toList()); }
  • java数组List互相转换

    千次阅读 2015-01-23 16:45:42
    1.List转换为数组  Collection 都有toArray()方法,可以由List直接转换为数组。   public T[] toArray(T[] a)返回一个按照正确的顺序包含此列表中所有元素的数组;返回数组的运行时类型就是指定数组的运行时...
  • 见代码: import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections;... * 将数组转list * @author gcc * * 2018年1月15日 */ public

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 460,111
精华内容 184,044
关键字:

java数组转list

java 订阅