Java基础（21）asList()方法、集合嵌套、Set集合、HashSet集合、LinkedHashSet集合、TreeSet集合

最新推荐文章于 2026-06-20 09:13:23 发布
原创 最新推荐文章于 2026-06-20 09:13:23 发布 · 931 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文详细介绍了Java中的asList()方法，包括其使用及注意事项；探讨了ArrayList的集合嵌套，展示了如何通过集合嵌套处理多层数据结构；深入讲解了Set接口及其具体实现类HashSet、LinkedHashSet和TreeSet，包括它们的特点、数据结构以及使用场景，特别提到了HashSet的去重功能和TreeSet的排序机制。

1. asList()方法

1. Arrays工具类的asList(T … t)方法的使用：将数组转化成集合
2. 传进来基本类型数组和引用类型数组的差别

public class TestDemo01 {
    public static void main(String[] args) {

        //传入引用类型
        List<String> strings = Arrays.asList("abc", "def", "ghi", "jkl");
        List<Integer> integers = Arrays.asList(111, 222, 333, 444, 555);
        System.out.println(strings);   //[abc, def, ghi, jkl]
        System.out.println(integers);   //[111, 222, 333, 444, 555]

        //传入一个基本类型的数组
        int[] arr = {10,20,30,40,50};
        List<int[]> ints = Arrays.asList(arr);
        System.out.println(ints.get(0)[1]);   //20 获取第一个数组的第二个元素
        System.out.println(ints.toString());   //[[I@3f99bd52]  存的是数组的地址值

        //传进来一个对象数组
        Integer[] integers1 = {12,22,32,42,52};
        List<Integer> integerList = Arrays.asList(integers1);
        System.out.println(integerList.get(1));   //22
        System.out.println(integerList);   //[12, 22, 32, 42, 52]

        //传进来多个基本类型的数组,转化的集合是：在这个集合中，放入了多个数组对象
        int[] arr1 = {11,12,13,14,15};
        int[] arr2 = {21,22,23,24,25};
        int[] arr3 = {31,32,33,34,35};
        List<int[]> intList = Arrays.asList(arr1, arr2, arr3);
        System.out.println(intList);

        //传进来多个对象数组，那么就把这个对象数组作为整体，放到集合中
        Integer[] arr4 = {12,22,32,42,52};
        Integer[] arr5 = {44,55,66,77,88};
        Integer[] arr6 = {31,41,51,61,71};
        List<Integer[]> integersList = Arrays.asList(arr4, arr5, arr6);
        System.out.println(integersList);
    }
}

在这里插入图片描述
3. 【注意事项】asList()得到的集合的长度是不可变的，也就是说不能对该集合进行add()和remove()方法

2. 集合嵌套之ArrayList嵌套ArrayList

1. 引入：我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList。但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList。 而我现在有多个ArrayList。也要用集合存储，怎么办呢?集合嵌套之ArrayList嵌套ArrayList
2. 代码示例

public class TestDemo02 {
    public static void main(String[] args) {
        ArrayList<Student> javaList = new ArrayList<>();
        javaList.add(new Student("ez",23));
        javaList.add(new Student("vn",24));

        ArrayList<Student> webList = new ArrayList<>();
        webList.add(new Student("noc",33));
        webList.add(new Student("mf",35));

        ArrayList<Student> linuxList = new ArrayList<>();
        linuxList.add(new Student("tf",36));
        linuxList.add(new Student("ag",38));

        //集合嵌套
        ArrayList<ArrayList<Student>> allList = new ArrayList<>();
        allList.add(javaList);
        allList.add(webList);
        allList.add(linuxList);

        //获取每一个人的信息:增强for
        for (ArrayList<Student> minList : allList) {
            for (Student student : minList) {
                System.out.println(student.getName() + "===" + student.getAge());
            }
        }
    }
}

class Student{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

3. Set集合

1. Set集合概述：一个不包含重复元素的Collection接口的子接口
2. Set集合的结构图
在这里插入图片描述

4. HashSet集合

1. HashSet概述：构造一个新的空set，其底层 HashMap 实例的默认初始容量是16
2. HashSet的数据结构：HashSet的底层是哈希表，元素无序（存取顺序不一致），不允许有重复元素，线程不安全。
3. HashSet集合存储基本类型的元素

public class TestDemo01 {
    public static void main(String[] args) {
        HashSet<String> stringHashSet = new HashSet<>();
        stringHashSet.add("张三");
        stringHashSet.add("李四");
        stringHashSet.add("王五");
        stringHashSet.add("张三");
        stringHashSet.add("伊泽瑞尔");
        stringHashSet.add("古拉加斯");
        stringHashSet.add("李四");
        stringHashSet.add("伊泽瑞尔");
        stringHashSet.add("赵六");

        System.out.println(stringHashSet);   //[李四, 张三, 王五, 赵六, 古拉加斯, 伊泽瑞尔]

        for (String s : stringHashSet) {
            System.out.println(s);   //李四    张三    王五    赵六    古拉加斯    伊泽瑞尔
        }

        System.out.println("================================");

        HashSet<Integer> integerHashSet = new HashSet<>();
        integerHashSet.add(11);
        integerHashSet.add(21);
        integerHashSet.add(31);
        integerHashSet.add(11);
        integerHashSet.add(22);
        integerHashSet.add(44);
        integerHashSet.add(31);
        integerHashSet.add(11);

        System.out.println(integerHashSet);   //[21, 22, 11, 44, 31]

        for (Integer integer : integerHashSet) {
            System.out.println(integer);    //21   22   11   44   31
        }
    }
}

4. HashSet集合存储引用类型元素

//没有重写hashCode()方法和equals()方法时
public class TestDemo02 {
    public static void main(String[] args) {
        HashSet<Student> studentHashSet = new HashSet<>();
        studentHashSet.add(new Student("ez",22));
        studentHashSet.add(new Student("tf",23));
        studentHashSet.add(new Student("vn",24));
        studentHashSet.add(new Student("ez",22));
        studentHashSet.add(new Student("vn",24));
        studentHashSet.add(new Student("ag",26));

        for (Student student : studentHashSet) {
            System.out.println(student.getName()+"==="+student.getAge());
        }
        /**
         * vn===24
         * ag===26
         * ez===22
         * ez===22
         * vn===24
         * tf===23
         * 这时候发现集合中重复的元素并没有被删掉
         * 因为HashSet集合保证元素唯一性是靠元素重写hashCode()方法和equals()方法来保证的
         * 如果元素不重写hashCode()方法和equals()方法，那么无法保证元素的唯一性
         */
    }
}

class Student{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

===============================================================

//重写hashCode()方法和equals()方法之后
public class TestDemo01 {
    public static void main(String[] args) {
        HashSet<Student> studentHashSet = new HashSet<>();
        studentHashSet.add(new Student("ez",22));
        studentHashSet.add(new Student("tf",23));
        studentHashSet.add(new Student("vn",24));
        studentHashSet.add(new Student("ez",22));
        studentHashSet.add(new Student("vn",24));
        studentHashSet.add(new Student("ag",26));

        for (Student student : studentHashSet) {
            System.out.println(student.getName()+"==="+student.getAge());
        }

        /**
         * vn===24
         * ez===22
         * ag===26
         * tf===23
         */

    }
}

class Student{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }
}

在这里插入图片描述
5. HashSet遍历集合

public class TestDemo02 {
    public static void main(String[] args) {
        HashSet<Integer> integerHashSet = new HashSet<>();
        integerHashSet.add(11);
        integerHashSet.add(22);
        integerHashSet.add(33);
        integerHashSet.add(44);

        //方式1：迭代器
        Iterator<Integer> iterator = integerHashSet.iterator();
        while (iterator.hasNext()) {
            Integer num = iterator.next();
            System.out.println(num);
        }

        //方式2：增强for
        for (Integer integer : integerHashSet) {
            System.out.println(integer);
        }
        
        //方式3：forEach()
        integerHashSet.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
    }
}

6. ArrayList去重元素的方法：HashSet(Collection < ? extends E > c)：构造一个包含指定 collection 中的元素的新 set

public class TestDemo03 {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(11);
        arrayList.add(21);
        arrayList.add(31);
        arrayList.add(11);
        arrayList.add(21);
        arrayList.add(51);
        arrayList.add(151);
        arrayList.add(116);

        System.out.println(arrayList);   //[11, 21, 31, 11, 21, 51, 151, 116]

        HashSet<Integer> integers = new HashSet<>(arrayList);
        System.out.println(integers);    //[51, 116, 21, 151, 11, 31]
    }
}

5. LinkedHashSet集合

1. LinkedHashSet概述：元素有序且唯一。线程不安全，效率高
2. LinkedHashSet底层数据结构：链表+哈希表。链表保证元素有序，哈希表保证元素唯一

public class TestDemo01 {
    public static void main(String[] args) {
        LinkedHashSet<Integer> integerLinkedHashSet = new LinkedHashSet<>();
        integerLinkedHashSet.add(11);
        integerLinkedHashSet.add(21);
        integerLinkedHashSet.add(31);
        integerLinkedHashSet.add(11);
        integerLinkedHashSet.add(41);
        integerLinkedHashSet.add(21);
        integerLinkedHashSet.add(51);
        integerLinkedHashSet.add(61);
        integerLinkedHashSet.add(31);

        System.out.println(integerLinkedHashSet);   //[11, 21, 31, 41, 51, 61]
    }
}

6. TreeSet集合

1. TreeSet集合概述：底层数据结构是二叉树，元素唯一，且能对元素进行排序
在这里插入图片描述
2. 对TreeSet的排序的两种方法
（1）自然排序：当你使用空参构造是，使用的就是自然排序。要求元素实现Comparable这个接口并重写compareTo()方法，根据比较的方法返回值的正负0，来决定元素在二叉树中放置的位置

//基本类型默认重写Comparable接口
public class TestDemo01 {
    public static void main(String[] args) {
        /**
         * Integer类实现了Comparable这个接口，重写了 compareTo
         *          public int compareTo (Integer anotherInteger){
         *             return compare(this.value, anotherInteger.value);
         *         }
         */
        TreeSet<Integer> integerTreeSet = new TreeSet<>();
        integerTreeSet.add(20);
        integerTreeSet.add(18);
        integerTreeSet.add(23);
        integerTreeSet.add(22);
        integerTreeSet.add(17);
        integerTreeSet.add(24);
        integerTreeSet.add(19);
        integerTreeSet.add(18);
        integerTreeSet.add(24);

        System.out.println(integerTreeSet);   //[17, 18, 19, 20, 22, 23, 24]
    }
}

========================================================================

//引用类型要自己手动重写Comparable接口
public class TestDemo02 {
    public static void main(String[] args) {
        TreeSet<Student> studentTreeSet = new TreeSet<>();
        studentTreeSet.add(new Student("vn",23));
        studentTreeSet.add(new Student("tf",25));
        studentTreeSet.add(new Student("ag",24));
        studentTreeSet.add(new Student("ez",27));

        for (Student student : studentTreeSet) {
            System.out.println(student.getName()+"==="+student.getAge());
        }

        /**
         * vn===23
         * ag===24
         * tf===25
         * ez===27
         */
    }
}

class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public int compareTo(Student s) {
        //先按照年龄大小来排序
        //this.xx - s.xx  从小到大排序
        int num = this.age - s.age;
        //年龄大小相同，并不能说明是同一个对象，还得比较名字是否相同
        int num2 = num==0 ? this.name.compareTo(s.name) : num;

        //从小到大排
        return num2;
    }
}

（2）比较器排序：TreeSet(Comparator < ? super E > comparator)：构造一个新的空 TreeSet，它根据指定比较器进行排序

public class TestDemo03 {
    public static void main(String[] args) {
        TreeSet<Integer> integerTreeSet = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //前-后：从小到大排序
                return o1 - o2;
            }
        });

        integerTreeSet.add(11);
        integerTreeSet.add(22);
        integerTreeSet.add(33);
        integerTreeSet.add(11);
        integerTreeSet.add(4);
        integerTreeSet.add(66);

        System.out.println(integerTreeSet);   //[4, 11, 22, 33, 66]

    }
}

======================================================================

//使用比较器，按照年龄大小来排序
public class TestDemo01 {
    public static void main(String[] args) {
        TreeSet<Student> studentTreeSet = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //比较年龄
                int num1 = o1.getAge() - o2.getAge();
                //如果年龄一样并不能说明是同一个对象，还要比较姓名是否一样
                int num2 = num1==0 ? o1.getName().compareTo(o2.getName()) : num1;

                return num2;
            }
        });
        studentTreeSet.add(new Student("ez",24));
        studentTreeSet.add(new Student("tf",25));
        studentTreeSet.add(new Student("tf",55));
        studentTreeSet.add(new Student("noc",27));
        studentTreeSet.add(new Student("vn",33));
        studentTreeSet.add(new Student("vn",33));

        for (Student student : studentTreeSet) {
            System.out.println(student.getName() + "===" + student.getAge());
        }
        /**
        ez===24
		tf===25
		noc===27
		vn===33
		tf===55
        */
    }
}

class Student{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

3. Comparator比较器
（1）Comparator比较器不光是TreeSet能用，其他的有些类也能使用
（2）比如Collection.sort()或者Arrays.sort()。可以将Comparator传递给sort()方法

public class TestDemo02 {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(11);
        integers.add(33);
        integers.add(44);
        integers.add(22);
        integers.add(66);
        integers.add(55);

        integers.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //从小到大
                return o1 - o2;
            }
        });

        System.out.println(integers);   //[11, 22, 33, 44, 55, 66]

        System.out.println("===========================================");

        int[] arr = {66,54,123,865,34,63};
        //默认从小到大排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));   //[34, 54, 63, 66, 123, 865]

        Integer[] arr2 = {66,54,123,865,34,63};
        Arrays.sort(arr2, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //从大到小排列
                return o2 - o1;
            }
        });
        System.out.println(Arrays.toString(arr2));   //[865, 123, 66, 63, 54, 34]
    }
}

4. TreeSet集合的两个练习
（1）编写一个程序，获取10个1至20的随机数，要求随机数不能重复

//编写一个程序，获取10个1至20的随机数，要求随机数不能重复
public class TestDemo01 {
    public static void main(String[] args) {
        Random r = new Random();
        TreeSet<Integer> integerTreeSet = new TreeSet<>();
        for (int i = 0; i < 10; i++) {
            int num = r.nextInt(20) + 1;
            integerTreeSet.add(num);
        }
        System.out.println(integerTreeSet);   //[1, 2, 3, 6, 9, 12, 13, 18, 19]
    }
}

（2）键盘录入3个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台

//键盘录入3个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台
public class TestDemo02 {
    public static void main(String[] args) {
        TreeSet<Student> studentTreeSet = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num1 = o1.sumNum() - o2.sumNum();
                int num2 = num1 == 0 ? o1.getName().compareTo(o1.getName()) : num1;
                //带负号：从高到低
                return -num2;
            }
        });

        for (int i = 1; i < 4; i++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入第" + i +"个学生的姓名");
            String s = sc.nextLine();
            System.out.println("请输入第" + i +"个学生的语文成绩");
            int yw = sc.nextInt();
            System.out.println("请输入第" + i +"个学生的数学成绩");
            int sx = sc.nextInt();
            System.out.println("请输入第" + i +"个学生的英语成绩");
            int yy = sc.nextInt();

            Student student = new Student(s, yw, sx, yy);
            studentTreeSet.add(student);
        }

        int i = 1;
        for (Student student : studentTreeSet) {
            System.out.println("第" + i++ +"个学生的姓名:" + student.getName() + "，总分是：" + student.sumNum());
        }
    }
}

class Student{
    private String name;
    private int chineseNum;
    private int mathNum;
    private int englishNum;

    public Student() {
    }

    public Student(String name, int chineseNum, int mathNum, int englishNum) {
        this.name = name;
        this.chineseNum = chineseNum;
        this.mathNum = mathNum;
        this.englishNum = englishNum;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getChineseNum() {
        return chineseNum;
    }

    public void setChineseNum(int chineseNum) {
        this.chineseNum = chineseNum;
    }

    public int getMathNum() {
        return mathNum;
    }

    public void setMathNum(int mathNum) {
        this.mathNum = mathNum;
    }

    public int getEnglishNum() {
        return englishNum;
    }

    public void setEnglishNum(int englishNum) {
        this.englishNum = englishNum;
    }

    public int sumNum(){
        return chineseNum + mathNum + englishNum;
    }
}
标签
#java
wzr-xupt
关注
Arrays.asList() 详解
qq_43613689的博客
12-31 3497
Arrays.asList() 详解 【1. 要点】 该方法是将数组转化成List集合的方法。 List list = Arrays.asList(“a”,“b”,“c”); 注意： （1）该方法适用于对象型数据的数组（String、Integer…） （2）该方法不建议使用于基本数据类型的数组（byte,short,int,long,float,double,boolean） （3）该方法将数组与List列表链接起来：当更新其一个时，另一个自动更新 （4）不支持add()、remove()、clear()
Java集合框架、3种循环方式对比、Lamabda表达式
の博客
03-31 479
javaList/map面试题
java中asList的使用
weixin_44874132的博客
10-19 1万+
asList概述 Java中的asList方法是数组工具类 Arrays中的一个静态方法，Arrays.asList()方法的作用是将数组或一些元素转为集合，asList方法返回值得到的集合并不是我们通常使用的List集合，asList()方法把数组转换成集合时,不能使用其修改集合相关的方法,如果使用修改集合相关的方法add/remove/clear方法会抛出java.lang.UnsupportedOperationException的异常。 1.使用asList方法返回的对象调用add/remove/c
Arrays.asList详解和示例
热门推荐
Venus's Blog
05-03 6万+
注意 （1）该方法适用于对象型数据的数组（String、Integer…） （2）该方法不建议使用于基本数据类型的数组（byte,short,int,long,float,double,boolean） （3）该方法将数组与List列表链接起来：当更新其一个时，另一个自动更新 （4）不支持add()、remove()、clear()等方法 （5）此方法得到的List长度是不可变的 （6）asLis...
java中的asList_Java Arrays.AsList原理及用法实例
weixin_31036949的博客
02-13 1886
java.util.Arrays的asList方法可以方便的将数组转化为集合，我们平时开发在初始化ArrayList时使用的比较多，可以简化代码，但这个静态方法asList()有几个坑需要注意:一. 如果对集合使用增加或删除元素的操作将会报错如下代码：List list = Arrays.asList("a","b","c");list.add("d");输出结果:Exception in thr...
Java基础（Arrays工具类）(asList()方法)（详细）
岁岁岁平安的博客
09-25 2773
本篇博客详细的分析和解析了Java提供的工具类"Arrays"、以及它提供的最常用的几种操作"基本类型的数组"或"对象数组"的方法。其中包括Arrays.sort()、Arrays.binarySearch()、Arrays.toString()、Arrays.asList()、Arrays.copyOfRange()、Arrays.fill()方法。详细的介绍了Arrays.asList()方法。
Java中的集合类图
smh821025的专栏
12-05 972
Java的集合类关系图： List：add/remove/get/set。 1，ArrayList：其实就是数组，容量一大，频繁增删就是噩梦，适合随机查找； 2，LinkedList：增加了push/[pop|remove|pull]，好啰嗦，其实都是removeFirst； 3，Vector：历史遗留产物，同步版的ArrayList，名字起的奇奇怪怪，代码和ArrayList太像
Java Stream distinct() 原理、性能陷阱与正确去重实践
最新发布
06-20 636
Java Stream 的 distinct() 是基于对象 equals() 和 hashCode() 实现的去重操作，其本质是内部维护一个 HashSet 进行哈希查重。该机制决定了它的时间复杂度依赖于哈希分布质量，空间复杂度与去重后元素数量呈线性关系。技术价值在于提供声明式去重能力，但误用将引发 Full GC 频发、CPU 100%、OOM 等生产事故。典型应用场景包括日志去重、订单项聚合、用户行为清洗等，但仅适用于中小规模数据及语义明确的可重写 equals/hashCode 对象。本文深入剖析
Java 常用特性整理（测开）
m0_37606579的博客
05-18 388
整理了 Java 测试开发日常高频用到的核心知识点，覆盖基础语法、面向对象、集合框架、异常处理、IO、多线程、泛型、反射、Lambda/Stream 等章节。
java八股文极速版
PassionAnytime的博客
06-02 288
时间和空间的权衡 值越高空间开销小但是增加了查找开销服务于从Key映射到index的Hash算法，在性能和内存的使用上取平衡，实现一个尽量均匀分布的Hash函数，选取16,是通过位运算的方法进行求取的。线程安全：当多线程执行同一段程序的时候，如果发生了和预期结果不一致的情况，就是线程不安全的，如果和预期结果一致就是线程安全的，可以加锁解决(把并行运行的线程变成串行化执行)。1.加锁 利用Synchronized或者ReenTrantLock来对不安全对象进行加锁。
Arrays.aslist用法及陷阱
Pre_waist_L的博客
05-09 3039
原文出处http://blog.csdn.net/chenleixing/article/details/43775127大家都知道这个方法是将数组转成list，是JDK中java.util包中Arrays类的静态方法。大家使用时一定要注意（请看代码和注释，一看就明String s[]={"aa","bb","cc"}; List&lt;String&gt; sList=Arrays.asLi...
一篇文章带你了解 asList数组转换List有哪些坑?
林夕
10-11 1113
一篇文章带你了解 asList数组转换List有哪些坑?
Java 中Arrays.aslist的作用
m0_63322122的博客
03-03 960
【代码】Java 中Arrays.aslist的作用。
java中aslist是什么意思_你经常用Arrays.asList(...)，但是你知道它里面的坑吗？
weixin_39821604的博客
02-27 690
我们经常会遇到这样一个场景：需要把数组转为集合更方便操作。一般使用Arrays.asList(arr)，但是我想找个方法里面的一些坑，很多乡亲们肯定是不知道的，我们今天就一起来看看。Arrays.asList(arr)的坑一1.1 示例代码publicclassArrayToListBug{privatestaticint[]articleNum={1,2,3,4};public...
aslist方法_一个细节 | Java中asList的缺陷
weixin_30586417的博客
12-04 717
今天在项目中的一段代码用了asList方法，出现了问题。作者于是仔细查看了asList的源码，在实际项目中避免出现错误的使用方式。希望对大家有帮助。在实际开发过程中我们经常使用 asList 讲数组转换为 List，这个方法使用起来非常方便，但是 asList 方法存在几个缺陷：一、避免使用基本数据类型数组转换为列表使用 8 个基本类型数组转换为列表时会存在一个比较有味的缺陷。先看如下程序： pu...
Arrays中的asList方法
墨笙弘一
03-13 1万+
今天分享一个Arrays类中的asList方法，首先看下面一个例子： import java.util.Arrays; import java.util.List; public class TestAsList { public static void main(String[] args){ int[] arr = {2,4,6,8,10}; Int...
java转list中的坑
henu_xiaohei的博客
06-02 306
一、不能把基本数据类型转化为列表 仔细观察可以发现asList接受的参数是一个泛型的变长参数，而基本数据类型是无法泛型化的。 解决方案： 　　要想把基本数据类型的数组转化为其包装类型的list，可以使用guava类库的工具方法，示例如下： int[] intArray = {1, 2, 3, 4}; List<Integer> list = Ints.asList(intArray); 二、asList方法返回的是数组的一个视图 视图意味着，对这个list的操作都会反映在原数组上，而且这个li
关于使用Arrays.asList和ArrayList.subList所踩的坑
GodSea_611的博客
01-22 2373
修改原集合结构再使用子集合会抛异常修改子集合结构原集合也会随之修改，追加元素的位置取决于toIndex修改原集合的元素会影响子集合，修改子集合元素会影响原集合。
Java Arrays.asList()方法详解
cristianoxm的博客
08-25 2万+
本文是对Arrays.asList()方法从源码角度进行分析，解析使用中的一些困惑。 首先看Arrays.asList()的源码 public static <T> List<T> asList(T... a) { return new ArrayList<T>(a); } 使用该方法 可以将一个变长参数或者数组转换成List 看似很简单但实际使用起来却会发现存在很多问题，看下面代码来发现问题。 先来看第一个问题，基本类型数组作为参数问题。 publi
java lists.aslist_java Arrays.asList()
weixin_42515372的博客
02-16 3334
在Java中比如想把一个数组转成集合,通常习惯使用Arrays.asList,但是要小心,数组通过Arrays.asList转成集合后,是不能调用集合的add,remove方法的.不然会抛异常UnsupportedOperationException,DemoInteger[] array = {1, 2};List list = Arrays.asList(array);list.remove(...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值