精华内容
下载资源
问答
  • 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”竟然有这么多的学问,震撼之余夹带些许不堪。

    不曾想到,“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集合 */ 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误区

    千次阅读 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", "...
  • java数组list的转换

    千次阅读 2018-09-08 21:45:19
    asList() 把数组转换成集合时,不能使用其修改集合相关的方法,它的 add / remove / clear 方法会抛出 UnsupportedOperationException 异常。 说明: asList 的返回对象是一个 Arrays 内部类,并没有实现集合的...
  • java数组List互相转换

    千次阅读 2015-01-23 16:45:42
    1.List转换为数组  Collection 都有toArray()方法,可以由List直接转换为数组。   public T[] toArray(T[] a)返回一个按照正确的顺序包含此列表中所有元素的数组;返回数组的运行时类型就是指定数组的运行时...
  • java 数组List转换

    2012-05-17 11:42:03
    数组->List Arrays.asList()   List->数组 Collections.asArray()
  • java数组List,Set,Map动态和静态初始化
  • 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...
  • 今天在开发中遇到对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...
  • java数组去重list.contains()的使用

    千次阅读 2017-02-21 16:51:21
    数字数组: int[] num=new int[]{4,2,7,2,4,9} List<Integer>list =new ArrayList(); for(int i=0;i;i++){ if(!list.contains(num[i])){ list.add(num[i]); } }字符数组: String[] str=n
  • JAVA 数组List连接成字符串

    万次阅读 2016-11-16 21:46:29
    (String join,List<String> listStr){ StringBuffer sb= new StringBuffer(); for ( int i= 0 ,len =listStr.size();i;i++){ if (i==(len- 1 )){ sb.append(listStr.get(i)); } else { sb.append(listStr....
  • 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日 ...
  • 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()); }
  • 最近开发中,业务上处理,经常用到asList方法,这让我不...大家都知道这个方法是将数组转成list,是JDK中java.util包中Arrays类的静态方法。大家使用时一定要注意(请看代码和注释,一看就明了了):  String s[]...
  • Java数组与容器类分析资料--数组、List和Set、Map等 数组是Java语言内置的类型,除此之外,Java有多种保存对象引用的方式。Java类库提供了一套相当完整的容器类,使用这些类的方法可以保存和操纵对象。下面分别进行...
  • java 输出数组list

    万次阅读 2018-08-21 22:06:00
    String[] array = new String[]{"1", "2"}; System.out.println(array); System.out.println(array.toString()); System.out.println(Arrays.toString(array));... List&lt;S...
  • 一. Incidentimport java.util.ArrayList; import java.util.List; public class Test { public static void main(String[] args) { List list = ne
  • 下面分别进行讨论,在研究Java容器类之前,先了解一下Java数组的基本功能和特性。 1. 数组的基本特性 数组与其它种类的容器(List/Set/Map)之间的区别在于效率、确定的类型和保存基本类型数据的能力。数组是一...
  • Java数组和各种List的性能比较

    千次阅读 2013-11-03 13:39:48
    Java数组和各种List的性能比较  以下程序分别对Java数组、ArrayList、LinkedList和Vector进行随机访问和迭代等操作,并比较这种集合的性能。 package cn.lion.test; public class PerformanceTest { ...
  • 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 数组过滤

    2020-08-04 17:12:48
    java 数组过滤 List<PgMenu> collect = pgMenuList.stream().filter(PgMenu -> PgMenu.getState() != 2).collect(Collectors.toList());
  • Java数组长参数详解

    千次阅读 2018-02-01 15:42:46
    java5中提供了可长参数,也就是在方法中一个可长参数可以代表同一类型的多个参数(数组);长参数使用String...str标识; 1.向可长参数方法传递多个参数 package extensions; public class ParamVar {...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 457,764
精华内容 183,105
关键字:

java数组变list

java 订阅