精华内容
下载资源
问答
  • asList详解

    2019-01-18 09:30:20
    asList(T... a)返回的是一个固定大小的list集合 源码分析: public static <T> List<T> asList(T... a) { return new ArrayList<>(a); } 此时的ArrayList为Arrays...
    asList(T... a)返回的是一个固定大小的list集合

    源码分析:

    public static <T> List<T> asList(T... a) {
            return new ArrayList<>(a);
        }

    此时的ArrayList为Arrays里面自定义的一个私有的内部类

     private static class ArrayList<E> extends AbstractList<E>
            implements RandomAccess, java.io.Serializable

    其父类AbstractList中事务方法都被禁止了,使用时需要确保返回的list不会去修改。若需要修改可以修改为

     new ArrayList<>(Arrays.asList(T... a));
     public E set(int index, E element) {
            throw new UnsupportedOperationException();
        }
    
        /**
         * {@inheritDoc}
         *
         * <p>This implementation always throws an
         * {@code UnsupportedOperationException}.
         *
         * @throws UnsupportedOperationException {@inheritDoc}
         * @throws ClassCastException            {@inheritDoc}
         * @throws NullPointerException          {@inheritDoc}
         * @throws IllegalArgumentException      {@inheritDoc}
         * @throws IndexOutOfBoundsException     {@inheritDoc}
         */
        public void add(int index, E element) {
            throw new UnsupportedOperationException();
        }
    
        /**
         * {@inheritDoc}
         *
         * <p>This implementation always throws an
         * {@code UnsupportedOperationException}.
         *
         * @throws UnsupportedOperationException {@inheritDoc}
         * @throws IndexOutOfBoundsException     {@inheritDoc}
         */
        public E remove(int index) {
            throw new UnsupportedOperationException();
        }

     

    展开全文
  • Arrays.asList() 详解

    万次阅读 多人点赞 2018-05-21 16:49:30
    list = Arrays.asList("a","b","c"); 注意: (1)该方法适用于对象型数据的数组(String、Integer...) (2)该方法不建议使用于基本数据类型的数组(byte,short,int,long,float,double,boolean) (3)该...

    【1. 要点】

     该方法是将数组转化成List集合的方法。

     List<String> list = Arrays.asList("a","b","c");

    注意:

    (1)该方法适用于对象型数据的数组(String、Integer...)

    (2)该方法不建议使用于基本数据类型的数组(byte,short,int,long,float,double,boolean)

    (3)该方法将数组与List列表链接起来:当更新其一个时,另一个自动更新

    (4)不支持add()、remove()、clear()等方法

     

     

    【2.Arrays.asList()是个坑】

    用此方法得到的List的长度是不可改变的,

    当你向这个List添加或删除一个元素时(例如 list.add("d");)程序就会抛出异常(java.lang.UnsupportedOperationException)。 怎么会这样?只需要看看asList()方法是怎么实现的就行了:

    public static <T> List<T> asList(T... a) {return new ArrayList<>(a);}

    当你看到这段代码时可能觉得没啥问题啊,不就是返回了一个ArrayList对象吗?问题就出在这里。

    这个ArrayList不是java.util包下的,而是java.util.Arrays.ArrayList

    它是Arrays类自己定义的一个静态内部类,这个内部类没有实现add()、remove()方法,而是直接使用它的父类AbstractList的相应方法。

    而AbstractList中的add()和remove()是直接抛出java.lang.UnsupportedOperationException异常的!

    public void add(int index, E element) { throw new UnsupportedOperationException();}

    public E remove(int index) {throw new UnsupportedOperationException();}

     

    总结:如果你的List只是用来遍历,就用Arrays.asList()。

               如果你的List还要添加或删除元素,还是乖乖地new一个java.util.ArrayList,然后一个一个的添加元素。

     

    【3.示例代码】

    package cn.wyc;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class Test {
        public static void main(String[] args){
    
           //1、对象类型(String型)的数组数组使用asList(),正常
            String[] strings = {"aa", "bb", "cc"};
            List<String> stringList = Arrays.asList(strings);
            System.out.print("1、String类型数组使用asList(),正常:  ");
            for(String str : stringList){
                System.out.print(str + " ");
            }
            System.out.println();
    
    
            //2、对象类型(Integer)的数组使用asList(),正常
            Integer[] integers = new Integer[] {1, 2, 3};
            List<Integer> integerList = Arrays.asList(integers);
            System.out.print("2、对象类型的数组使用asList(),正常:  ");
            for(int i : integerList){
                System.out.print(i + " ");
            }
    //        for(Object o : integerList){
    //            System.out.print(o + " ");
    //        }
            System.out.println();
    
    
            //3、基本数据类型的数组使用asList(),出错
            int[] ints = new int[]{1, 2, 3};
            List intList = Arrays.asList(ints);
            System.out.print("3、基本数据类型的数组使用asList(),出错(输出的是一个引用,把ints当成一个元素了):");
            for(Object o : intList){
                System.out.print(o.toString());
            }
            System.out.println();
    
            System.out.print("   " + "这样遍历才能正确输出:");
            int[] ints1 = (int[]) intList.get(0);
            for(int i : ints1){
                System.out.print(i + " ");
            }
            System.out.println();
    
            //4、当更新数组或者List,另一个将自动获得更新
            System.out.print("4、当更新数组或者List,另一个将自动获得更新:  ");
            integerList.set(0, 5);
            for(Object o : integerList){
                System.out.print(o + " ");
            }
            for(Object o : integers){
                System.out.print (o + " ");
            }
            System.out.println();
    
            //5、add()   remove() 报错
            System.out.print("5、add()   remove() 报错:  ");
    //        integerList.remove(0);
    //        integerList.add(3, 4);
    //        integerList.clear(); 
        }
    
    }
    

    输出:

    1、String类型数组使用asList(),正常:  aa bb cc 
    2、对象类型的数组使用asList(),正常:  1 2 3 
    3、基本数据类型的数组使用asList(),出错(输出的是一个引用,把ints当成一个元素了):[I@1540e19d
       这样遍历才能正确输出:1 2 3 
    4、当更新数组或者List,另一个将自动获得更新:  5 2 3 5 2 3 
    5、add()、remove()、clear() 报错: 

     

     

     

     

     

     

     

     

    展开全文
  • Arrays.asList方法总结

    2020-08-31 12:49:04
    本文主要对Arrays.asList方法进行总结。具有很好的参考价值,下面跟着小编一起来看下吧
  • Arrays.asList

    2019-06-11 11:07:16
    一般情况下,使用Arrays.asList()的原因无非是想将数组或一些元素转为集合,而你得到的集合并不一定是你想要的那个集合。 asList在最初设计时用于打印数组,但jdk1.5开始,有了另一个比较更方便的打印函数Arrays....

    一般情况下,使用Arrays.asList()的原因无非是想将数组或一些元素转为集合,而你得到的集合并不一定是你想要的那个集合

    asList在最初设计时用于打印数组,但jdk1.5开始,有了另一个比较更方便的打印函数Arrays.toString(),于是打印不再使用asList(),而asList()恰巧可用于将数组转为集合。

    一、首先看几个例子:

    (1)将基本类型数组作为asList参数

    		String[] strArr = {"A","B","C"};
    		List<String> asList = Arrays.asList(strArr);
    		System.out.println("封装类型String时:" + asList.size());
    
    		int[] intArr = {1, 2, 3};
    		List<String> list = Arrays.asList(intArr);
    		System.out.println("基本类型时:" + list.size());
    

    运行结果:

    封装类型String时:3
    基本类型时:1
    

    (2)将数组作为asList参数后,修改数组或List

    		String[] strArr = {"A","B","C"};
    		List<String> asList = Arrays.asList(strArr);
    		strArr[0] = "a";
    		asList.set(1, "b");
    		System.out.println(Arrays.toString(strArr));
    		System.out.println(asList.toString());
    

    运行结果:

    [a, b, C]
    [a, b, C]
    

    strArr和asList 中的数据都会改变

    (3)数组转换为集合后,进行增删元素

    		String[] strArr = {"A","B","C"};
    		List<String> asList = Arrays.asList(strArr);
    		asList.add("1");
    		asList.remove("C");
    		System.out.println(asList.toString());
    

    运行结果:

    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.my.tests.TestArrayAsList.main(TestArrayAsList.java:9)
    

    二、深入研究

    这里要关注的地方在于:
    Arrays.asList()返回的List是:Arrays.ArrayList,而不是java.util.ArrayList
    在这里插入图片描述
    两者的不同之处:
    Arrays.ArrayList是工具类Arrays的一个内部静态类,它没有完全实现List方法,而ArrayList直接实现了List接口,实现了List所有方法。

    • 长度不同和实现的方法不同:
      Arrays.ArrayList是一个定长集合,因为它没有重写add,remove方法,所以,一旦初始化元素后,集合的size就是不可变的。
    • 参数赋值方式不同
      Arrays.ArrayList将外部数组的引用直接通过“=”赋予内部的泛型数组,所以本质指向同一个数组。而ArrayList是将其他集合转为数组后copy到自己内部的数组的。
    // 以下是JDK8版本中的Arrays.ArrayList
        public static <T> List<T> asList(T... a) {
            return new ArrayList<>(a);
        }
        private static class ArrayList<E> extends AbstractList<E>
            implements RandomAccess, java.io.Serializable
        {
            private final E[] a;
    
            ArrayList(E[] array) {
                a = Objects.requireNonNull(array);	// 此处是直接赋值的,所以本质指向的是同一个数组
         	}
       	}
    
    // 以下是JDK8中java.util.ArrayList
        public ArrayList(Collection<? extends E> c) {
            elementData = c.toArray();	// toArray底层使用的是数组clone或System.arraycopy
            if ((size = elementData.length) != 0) {
                // c.toArray might (incorrectly) not return Object[] (see 6260652)
                if (elementData.getClass() != Object[].class)
                    elementData = Arrays.copyOf(elementData, size, Object[].class);
            } else {
                // replace with empty array.
                this.elementData = EMPTY_ELEMENTDATA;
            }
        }
    

    在这里插入图片描述

    三、案例解析

    对于第一个例子:(1)将基本类型数组作为asList参数
    由于Arrays.ArrayList参数为可变长泛型,而基本类型是无法泛型化的,所以它把int[] arr数组当成了一个泛型对象,所以集合中最终只有一个元素arr。

    对于第二个例子:(2)将数组作为asList参数后,修改数组或List
    由于asList产生的集合元素是直接引用作为参数的数组,所以当外部数组或集合改变时,数组和集合会同步变化,这在平时我们编码时可能产生莫名的问题。

    对于第三个例子:(3)数组转换为集合后,进行增删元素
    由于asList产生的集合并没有重写add,remove等方法,所以它会调用父类AbstractList的方法,而父类的方法中抛出的却是异常信息。

    四、支持基础类型的方式

    1、如果使用Spring

    import org.springframework.util.CollectionUtils;
    
    public class Temp {
    	public static void main(String[] args) {
    		int[] arr = {1,2,3};
    		List list = CollectionUtils.arrayToList(arr);
    		System.out.println(list);
    	}
    }
    

    运行结果:

    [1, 2, 3]
    

    2、直接使用Java8

    		int intArray[] = {1,2,3};
    		List<Integer> iList = Arrays.stream(intArray)
    				.boxed()
    				.collect(Collectors.toList());
    		System.out.println(iList);
    

    运行结果:

    [1, 2, 3]
    

    五、数组转ArrayList

    1、遍历转换

    		Integer intArray[] = {1,2,3};
    		ArrayList<Integer> arrayList = new ArrayList<>();
    		for (Integer i : arrayList) {
    			arrayList.add(i);
    		}
    

    2、使用工具类(更加优雅)

    		ArrayList<String> list = new ArrayList();
    		Collections.addAll(list, "A", "B", "C");
    

    3、对于JAVA8
    既可以用于基本类型也可以返回想要的集合。

    		int intArray[] = {1,2,3};
    		List<Integer> iList = Arrays.stream(intArray)
    				.boxed()
    				.collect(Collectors.toList());
    		System.out.println(iList);
    

    运行结果:

    [1, 2, 3]
    

    4、还有另外一种方法
    两个集合类结合:将Arrays.asList返回的集合作为ArrayList的构造参数

    		ArrayList arrayList = new ArrayList<>(
    				Arrays.asList("A", "B", "C")
    				);
    
    展开全文
  • 千万不要这样使用Arrays.asList !

    万次阅读 多人点赞 2019-06-10 14:46:54
    作者:flyhero | 微信公众号:码上实战(ID:...而一开始asList的设计时用于打印数组而设计的,但jdk1.5开始,有了另一个比较更方便的打印函数Arrays.toString(),于是打印不再使用asList(),而asList()恰巧可用于将数...

    作者:flyhero | 微信公众号:码上实战(ID:Push-Code)

    使用Arrays.asList()的原因无非是想将数组或一些元素转为集合,而你得到的集合并不一定是你想要的那个集合。

    而一开始asList的设计时用于打印数组而设计的,但jdk1.5开始,有了另一个比较更方便的打印函数Arrays.toString(),于是打印不再使用asList(),而asList()恰巧可用于将数组转为集合。

    一、错误用法

    如果你这样使用过,那你可要注意了。

    1、错误一

    将基本类型数组作为asList的参数

    猜一下输出结果?

    2、错误二

    将数组作为asList参数后,修改数组或List
    在这里插入图片描述

    猜一下输出结果?

    3、错误三

    数组转换为集合后,进行增删元素

    在这里插入图片描述

    猜一下输出结果?

    你是不是以为上面 ?那个 list 是 java.util.ArrayList ?

    答案很确定:NO !

    在这里插入图片描述

    二、深入探究

    我们通过asList()源码可发现其原因,但为了更直观,我们先通过IDEA debug来看看结果。
    在这里插入图片描述

    在这里插入图片描述

    其实它返回的是 java.util.Arrays.ArrayList,这个家伙是谁呢?
    在这里插入图片描述

    请看下源码:
    在这里插入图片描述

    但它和ArrayList貌似很像唉!有什么不同吗?

    三、不同之处

    Arrays.ArrayList 是工具类 Arrays 的一个内部静态类,它没有完全实现List的方法,而 ArrayList直接实现了List 接口,实现了List所有方法。

    在这里插入图片描述

    • 长度不同 和 实现的方法不同

      Arrays.ArrayList是一个定长集合,因为它没有重写add,remove方法,所以一旦初始化元素后,集合的size就是不可变的。

    • 参数赋值方式不同

    Arrays.ArrayList将外部数组的引用直接通过“=”赋予内部的泛型数组,所以本质指向同一个数组。
    在这里插入图片描述

    ArrayList是将其他集合转为数组后copy到自己内部的数组的。

    在这里插入图片描述

    四、揭晓答案

    1、错误一

    由于Arrays.ArrayList参数为可变长泛型,而基本类型是无法泛型化的,所以它把int[] arr数组当成了一个泛型对象,所以集合中最终只有一个元素arr。

    2、错误二

    由于asList产生的集合元素是直接引用作为参数的数组,所以当外部数组或集合改变时,数组和集合会同步变化,这在平时我们编码时可能产生莫名的问题。

    3、错误三

    由于asList产生的集合并没有重写add,remove等方法,所以它会调用父类AbstractList的方法,而父类的方法中抛出的却是异常信息。

    五、支持基础类型的方式

    1、如果使用Spring

    在这里插入图片描述

    2、如果使用Java 8

    在这里插入图片描述

    六、数组转ArrayList

    1、遍历转换

    在这里插入图片描述
    显然这种方式不够优雅!反正我不愿意使用。

    2、使用工具类

    上面方案不够优雅,那么这种相对来说优雅一些。

    在这里插入图片描述
    你以为这种还不错?
    too young too simple!
    addAll()方法的实现就是用的上面遍历的方式。

    3、如果使用Java 8

    既可以用于基本类型也可以返回想要的集合。
    在这里插入图片描述

    4、两个集合类结合

    将Arrays.asList返回的集合作为ArrayList的构造参数

    在这里插入图片描述

    七、最后

    勿以点小而不闻!体现程序素养或许就在这些小地方,不要给自己或别人留坑。那么这个知识点,你get到了吗?

    热门内容:

    1、2019年程序员高考真题新鲜出炉!看看你能得几分!

    2、从开源小白到 Apache Member,我的成长之路!

    3、GitHub 五万星登顶,命令行的艺术!

    4、19 个强大、有趣、好玩、又装B的 Linux 命令!

    5、如何正确访问Redis中的海量数据?服务才不会挂掉!

    6、为什么有些大公司技术弱爆了?

    7、必会的55个Java性能优化细节!一网打尽!

    8、面试题:InnoDB中一棵B+树能存多少行数据?

    【视频福利】2T免费学习视频,搜索或扫描上述二维码关注微信公众号:Java后端技术(ID: JavaITWork),和20万人一起学Java!回复:1024,即可免费获取!内含SSM、Spring全家桶、微服务、MySQL、MyCat、集群、分布式、中间件、Linux、网络、多线程,Jenkins、Nexus、Docker、ELK等等免费学习视频,持续更新!

    展开全文
  • Arrays.asList()这个方法可以将数组转换为集合。1.List list = Arrays.asList(reports);String reportStr= "皕杰报表,分析报表,部署报表";String[] reports = reportStr.split(",");List list = Arrays.asList...
  • 主要介绍了Java Arrays.asList使用方法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • aslist(排序列表)是golang语言实现的线程安全可排序的列表。便捷的调用方式,使开发者快速入门使用。 快速开始 go get -u github.com/CreditTone/aslist 如果你使用gomod管理依赖 go get -u github....
  • 主要介绍了java 源码分析Arrays.asList方法详解的相关资料,需要的朋友可以参考下
  • 主要给大家介绍了关于为什么说千万别这样使用Arrays.asList()的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用java具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • asList 的缺陷

    2018-02-01 10:18:11
    asList 的缺陷在实际开发过程中我们经常使用 asList 讲数组转换为 List,这个方法使用起来非常方便,但是 asList 方法存在几个缺陷:一、避免使用基本数据类型数组转换为列表使用 8 个基本类型数组转换为列表时会...
  • 浅谈asList

    2018-12-10 14:29:13
    数组转化为List是在编程中经常用到的问题,我们经常需要使用Array的asList()函数进行转化,但在使用时,经常会遇到一些问题,有一些问题需要我们注意。 1.由asList()转化而来的List底层表示的数组,因此不能...
  • Arrays.asList踩坑

    2020-09-07 10:31:40
    一不小心在项目里用到了Arrays.asList,将一个数组转换成List了,结果在调用add的时候报java.lang.UnsupportedOperationException异常,之前只是在网上的其他资料里看到过不要使用Arrays.asList转换数组,没有具体去...
  • what is the difference between1.List list1 = new ArrayList(Arrays.asList(ia)); //copy2.List list2 = Arrays.asList(ia);where ia is array of integers.I came to know that some operations are not allowed....
  • asList的坑

    2020-06-24 15:42:21
    List list = Arrays.asList(“a”,“b”,“c”); 注意: (1)该方法适用于对象型数据的数组(String、Integer…) (2)该方法不建议使用于基本数据类型的数组(byte,short,int,long,float,double,boolean) (3)...
  • Arrays asList 源码剖析

    2019-04-24 09:59:00
    Arrays asList 源码剖析
  • 本文主要介绍了Arrays.asList()方法的使用。具有很好的参考价值,下面跟着小编一起来看下吧
  • 在本篇文章里小编给大家分享的是关于Java中使用Arrays.asList初始化ArrayList的知识点内容,需要的朋友们参考下。
  • Arrays的asList方法

    2021-01-09 16:35:03
    Arrays中有一个方法asList方法。是将任何类型的数组转换为list形式。 将任何类型的数组转换成List集合 注意:缺点是由此形式创建的集合不可以使用add方法 for (String arg : Arrays.asList(s)) { System.out....
  • Java asList出错

    2018-04-24 14:02:03
    代码片段:String[] array = new String[]{"2","3","4","5","6"... list = java.util.Arrays.asList(array)...}报错如下:、报错原因:调用Arrays.asList()生产的Li
  • Arrays.asList()

    2021-04-16 14:22:02
    Arrays.asList() Arrays.asList()在平时开发中比较常见,可以使用它将一个数组转换成为一个List集合 String[] myArray = {"a","b","c"}; List<String> list = Arrays.asList(myArray); 等价于 List<String&...
  • 主要介绍了Java中Arrays.asList()方法将数组作为列表时的一些差异的相关资料,需要的朋友可以参考下
  • asList的用法

    2018-08-02 15:33:00
    public class Demo9 { public static void main(String[] args){ //数组转集合 String[] strArr={ "hello","world"}; List<String> list1 = Arrays.asList(strArr); System.out.pri...
  • java中aslist总结

    2020-04-10 23:16:45
    #java中aslist总结 可以看到在书中对这个知识点说的十分模糊。我们来看代码就懂了 #1 在这里插入代码片 String a[]={"123","234","345"}; List<String> list1= Arrays.asList(a); for (String s:list1) {...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 137,275
精华内容 54,910
关键字:

aslist