• 【Java基础】· 集合习题详解

    写在前面

            Hello大家好， 我是【麟-小白】，一位软件工程专业的学生，喜好计算机知识。希望大家能够一起学习进步呀！本人是一名在读大学生，专业水平有限，如发现错误或不足之处，请多多指正！谢谢大家！！！

            如果小哥哥小姐姐们对我的文章感兴趣，请不要吝啬你们的小手，多多点赞加关注呀！❤❤❤ 爱你们！！！

    目录

    写在前面

    Collection 和 Collections的区别

    Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别

    List, Set, Map是否继承自Collection接口

    两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对

    说出ArrayList,Vector, LinkedList的存储性能和特性

    HashMap和Hashtable的区别

    ArrayList和Vector的区别

    你所知道的集合类都有哪些？主要方法？

    定义一个Collection接口类型的变量，引用一个Set集合的实现类，实现添加单个元素，添加另一个集合，删除元素，判断集合中是否包含一个元素，判断是否为空，清除集合，返回集合里元素的个数等常用操作。

    创建Set接口的实现类，添加10个以上的元素，通过Iterator遍历此集合元素。

    创建Set接口的实现类，添加10个以上的元素，通过foreach遍历此集合元素。

    创建Set接口的实现类，添加10个以上的元素，要求能够排序。

    创建Car类，包含name，price属性，构造器等方法，创建测试类，在main方法中创建Set接口的实现类，添加5个以上的Car对象，遍历集合元素，验证重复元素是否过滤了；如果没有过滤，实现过滤功能；把每个小车的price降10000元，再遍历，查看price是否已改变

    创建ArrayList实例化对象，添加10个以上的元素，在2号位插入一个元素，获得5号位元素，删除6号位元素，修改7号位的元素；

    定义一个Map接口类型的变量，引用一个实现类，添加键值对，判断集合中是否包含某一key值，通过某一key值得到value值，通过某一key删除键值对，把另一个map集合添加到此map集合，判断是否为空，清除集合，返回集合里元素的个数等常用操作。通过两种方法遍历map集合

    使用Map接口的实现类完成员工工资(姓名--工资)的摸拟：

    1)添加几条信息

    2)列出所有的员工姓名

    3)列出所有员工姓名及其工资

    4)删除名叫“Tom”的员工信息

    5)输出Jack的工资，并将其工资加1000元(通过取值实现)

    6)将所有工资低于1000元的员工的工资上涨20%(通过取值实现)

    封装一个新闻类，包含标题、作者、新闻内容和发布时间，新闻标题如下：

    按要求完成如下操作 

    按要求完成如下操作

    以下代码的运行结果？

    结语

    【集合精讲】

    一文带你深入理解【Java基础】· Java集合（下）

    一文带你深入理解【Java基础】· Java集合（中）

    一文带你深入理解【Java基础】· Java集合（上）

    Collection 和 Collections的区别

    答：Collection是集合类的上级接口，继承于他的接口主要有Set 和List.

    Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作

    Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别

    答：Set里的元素是不能重复的，用equals()方法判读两个Set是否相等

        equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值

    List, Set, Map是否继承自Collection接口

    答： List，Set是，Map不是

    两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对

    答：不对，有相同的hash code

    说出ArrayList,Vector, LinkedList的存储性能和特性

    答：ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

    HashMap和Hashtable的区别

    答：

    1.HashMap与Hashtable都实现了Map接口。由于HashMap的非线程安全性，效率上可能高于Hashtable。Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。

    2. HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。

    3.HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。

    4.Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。

    5.Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

    ArrayList和Vector的区别

    答：就ArrayList与Vector主要从二方面来说.

    一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的

    二.数据增长:当需要增长时,Vector默认增长为原来的2培，而ArrayList却是原来的1.5倍

    你所知道的集合类都有哪些？主要方法？

    答：最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。

    Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作"键"和"值"），其中每个键映射到一个值。

    定义一个Collection接口类型的变量，引用一个Set集合的实现类，实现添加单个元素，添加另一个集合，删除元素，判断集合中是否包含一个元素，判断是否为空，清除集合，返回集合里元素的个数等常用操作。

    1. import java.util.HashSet;
    2. import java.util.Iterator;
    3. import java.util.Set;
    4.  
    5. public class Test {
    6.     public static void main(String[] args) {
    7.         //引用一个Set集合实现类
    8.        Set set = new HashSet();
    9.        //添加单个元素
    10.        set.add("哈");
    11.        set.add("士");
    12.        set.add("奇");
    13.        //添加另一个Set集合
    14.        Set S = new HashSet();
    15.        //将一个集合的所有元素添加到另一个集合
    16.        S.addAll(set);
    17.        //移除指定元素
    18.        S.remove("哈");
    19.        //判断集合中是否包含另一个元素
    20.        System.out.println("集合中是否含有“哈”：" + S.contains("哈"));
    21.        //判断是否为空
    22.        System.out.println("集合是否为空：" + S.isEmpty());
    23.        //清除集合
    24.        S.clear();
    25.        //返回集合元素个数
    26.        System.out.println(S.size());
    27.    }
    28. }

    创建Set接口的实现类，添加10个以上的元素，通过Iterator遍历此集合元素。

    1. public static void main(String[] args) {
    2.     //创建Set接口的实现类
    3.     Set set1 = new HashSet();
    4.  
    5.     //添加10个以上的元素
    6.     set1.add(22);
    7.     set1.add(2);
    8.     set1.add(55);
    9.     set1.add(78);
    10.     set1.add(5);
    11.     set1.add(15);
    12.     set1.add(7);
    13.     set1.add(30);
    14.     set1.add(9);
    15.     set1.add(70);
    16.     set1.add(11);
    17.  
    18.     //通过Iterator遍历此集合元素
    19.     Iterator iterator = set1.iterator();
    20.     while(iterator.hasNext()){
    21.         System.out.print(iterator.next() + " ");
    22.     }
    23. }

    创建Set接口的实现类，添加10个以上的元素，通过foreach遍历此集合元素。

    1. public class SetTest {
    2.     @Test
    3.     public void test1() {
    4.         HashSet objects = new HashSet<>();
    5.         objects.add("123");
    6.         objects.add("drtg");
    7.         objects.add("25");
    8.         objects.add("srthy");
    9.         objects.add("zxc");
    10.         objects.add("tdfh");
    11.         objects.add("453");
    12.         objects.add("SDGFrdsh");
    13.         objects.add("zx254c");
    14.         objects.add("sdGFSD");
    15.         objects.add("578585");
    16.  
    17.         for (Object obj : objects) {
    18.             System.out.println(obj);
    19.         }
    20.     }
    21. }
      22.  

       

       

       

      创建Set接口的实现类，添加10个以上的元素，要求能够排序。
       

      1. @Test
      2.     public void test2() {
      3.         TreeSet set1 = new TreeSet<>();
      4.         set1.add(123);
      5.         set1.add(456);
      6.         set1.add(789);
      7.         set1.add("asd");
      8.         set1.add("zxc");
      9.         set1.add("sdfg");
      10.         set1.add("qwe");
      11.         set1.add(856);
      12.         set1.add(649815);
      13.         set1.add(4563);
      14.         set1.add("dafdsgf");
      15.         set1.add(65);
      16.         set1.add(13);
      17.         set1.add(63);
      18.  
      19.         for (Object obj : set1) {
      20.             System.out.println(obj);
      21.         }
      22.     }
        23.  

         

         

         

        创建Car类，包含name，price属性，构造器等方法，创建测试类，在main方法中创建Set接口的实现类，添加5个以上的Car对象，遍历集合元素，验证重复元素是否过滤了；如果没有过滤，实现过滤功能；把每个小车的price降10000元，再遍历，查看price是否已改变
         

        car
         

        1. public class Car {
        2.     //创建Car类，包含name，price属性，构造器等方法
        3.  
        4.     private String name;
        5.  
        6.     private int price;
        7.  
        8.     public Car() {
        9.     }
        10.  
        11.     public Car(String name, int price) {
        12.         this.name = name;
        13.         this.price = price;
        14.     }
        15.  
        16.     public String getName() {
        17.         return name;
        18.     }
        19.  
        20.     public void setName(String name) {
        21.         this.name = name;
        22.     }
        23.  
        24.     public int getPrice() {
        25.         return price;
        26.     }
        27.  
        28.     public void setPrice(int price) {
        29.         this.price = price;
        30.     }
        31.  
        32.     @Override
        33.     public String toString() {
        34.         return "name=" + name +
        35.                 "  price=" + price;
        36.     }
        37. }
         

        测试类：
         

        1. public class CarTest {
        2.     public static void main(String[] args) {
        3.         //创建测试类，在main方法中创建Set接口的实现类
        4.         Set set = new TreeSet<>(new Comparator() {
        5.             @Override
        6.             public int compare(Car o1, Car o2) {
        7.                 int num = o1.getName().compareTo(o2.getName());
        8.                 int num1 = num == 0 ? o1.getPrice() - o2.getPrice() : num;
        9.                 return num1;
        10.             }
        11.         });
        12.  
        13.         //添加5个以上的Car对象
        14.         set.add(new Car("沃尔沃",250000));
        15.         set.add(new Car("大众",150000));
        16.         set.add(new Car("凯迪拉克",350000));
        17.         set.add(new Car("奥迪",550000));
        18.         set.add(new Car("雷克萨斯",950000));
        19.         set.add(new Car("雷克萨斯",950000));
        20.  
        21.         //遍历集合元素，验证重复元素是否过滤了，如果没有过滤，实现过滤功能
        22.         for (Car car : set){
        23.             System.out.println(car);
        24.         }
        25.         System.out.println("------------------------------");
        26.  
        27.         //把每个小车的price降10000元,再遍历，查看price是否已改变
        28.         for (Car car : set){
        29.             car.setPrice(car.getPrice()-10000);
        30.             System.out.println(car);
        31.         }
        32.     }
        33. }
         

         

         

         

        创建ArrayList实例化对象，添加10个以上的元素，在2号位插入一个元素，获得5号位元素，删除6号位元素，修改7号位的元素；
         

        1. @Test
        2.     public void Test3() {
        3.         ArrayList list = new ArrayList<>();
        4.         list.add(123);
        5.         list.add(123);
        6.         list.add(123);
        7.         list.add(123);
        8.         list.add(123);
        9.         list.add(123);
        10.         list.add(123);
        11.         list.add(123);
        12.         list.add(123);
        13.         list.add(123);
        14.         list.add(123);
        15.         list.add(2, 365);
        16.         System.out.println(list.get(5));
        17.         list.remove(6);
        18.         list.set(7, 666);
        19.         Iterator iterator = list.iterator();
        20.         while (iterator.hasNext()) {
        21.             System.out.println(iterator.next());
        22.         }
        23.     }
          24.  

           

           

           

          定义一个Map接口类型的变量，引用一个实现类，添加键值对，判断集合中是否包含某一key值，通过某一key值得到value值，通过某一key删除键值对，把另一个map集合添加到此map集合，判断是否为空，清除集合，返回集合里元素的个数等常用操作。通过两种方法遍历map集合
           

          1. import java.util.HashMap;
          2. import java.util.Map;
          3. import java.util.Set;
          4.  
          5.     @Test
          6.     public void test4() {
          7.         // 定义一个Map接口类型的变量，引用一个实现类
          8.         HashMap hashMap = new HashMap();
          9.  
          10.         //添加键值对
          11.         hashMap.put("123", "你好");
          12.         hashMap.put("蜂蜜", "柚子茶");
          13.         hashMap.put("Lisa", "Rose");
          14.  
          15.         //判断集合中是否包含某一key值
          16.         System.out.println(hashMap.containsKey("蜂蜜"));//ture
          17.  
          18.         //通过某一key值得到value值
          19.         System.out.println(hashMap.get("123"));//你好
          20.  
          21.         //通过某一key删除键值对
          22.         hashMap.remove("蜂蜜");
          23.         System.out.println(hashMap); //{123=你好, Lisa=Rose}
          24.  
          25.         //把另一个map集合添加到此map集合
          26.         HashMap hashMap1 = new HashMap();
          27.         hashMap1.putAll(hashMap);
          28.  
          29.         //判断是否为空
          30.         System.out.println(hashMap.isEmpty());//false
          31.  
          32.         //清除集合
          33.         hashMap.clear();
          34.  
          35.         //返回集合里元素的个数
          36.         System.out.println(hashMap.size()); //0
          37.  
          38.         //通过两种方法遍历上题中的map集合
          39.         //方式一
          40.         Set keySet = hashMap1.keySet();
          41.         for (String key : keySet) {
          42.             String value = hashMap1.get(key);
          43.             System.out.println("key:" + key + " , " + "value:" + value);
          44.         }
          45.         System.out.println("-------------------------");
          46.         //方式二
          47.         Set> entrySet = hashMap1.entrySet();
          48.         for (Map.Entry me : entrySet) {
          49.             String key = me.getKey();
          50.             String value = me.getValue();
          51.             System.out.println("key:" + key + " , " + "value:" + value);
          52.         }
          53.     }
           

           

           

          使用Map接口的实现类完成员工工资(姓名--工资)的摸拟：
           

          1)添加几条信息
           

          2)列出所有的员工姓名
           

          3)列出所有员工姓名及其工资
           

          4)删除名叫“Tom”的员工信息
           

          5)输出Jack的工资，并将其工资加1000元(通过取值实现)
           

          6)将所有工资低于1000元的员工的工资上涨20%(通过取值实现)
           

          1. @Test
          2.     public void test5() {
          3.         HashMap hashMap = new HashMap();
          4.  
          5.         //1)添加几条信息
          6.         hashMap.put("Pamela", 5000);
          7.         hashMap.put("Jack", 4800);
          8.         hashMap.put("Tom", 6100);
          9.         hashMap.put("Lee", 800);
          10.         hashMap.put("Lara", 500);
          11.  
          12.         //2)列出所有的员工姓名
          13.         Set keySet = hashMap.keySet();
          14.         System.out.println("员工姓名：" + keySet);
          15.  
          16.         //3)列出所有员工姓名及其工资
          17.         for (String key : keySet) {
          18.             //5)输出Jack的工资，并将其工资加1000元(通过取值实现)
          19.             if (hashMap.get(key).equals("Jack")) {
          20.                 int value = hashMap.get(key) + 1000;
          21.                 hashMap.put("Jack", value);
          22.             }
          23.  
          24.             //6)将所有工资低于1000元的员工的工资上涨20%(通过取值实现)
          25.             if (hashMap.get(key) < 1000) {
          26.                 double value = (hashMap.get(key) + (hashMap.get(key) * 0.2));
          27.                 hashMap.put(key, (int) value);
          28.             }
          29.             int value = hashMap.get(key);
          30.             System.out.println("姓名：" + key + " , " + "工资：" + value);
          31.         }
          32.  
          33.         //4)删除名叫“Tom”的员工信息
          34.         hashMap.remove("Tome");
          35.     }
           

           

           

          封装一个新闻类，包含标题、作者、新闻内容和发布时间，新闻标题如下：
           

          新闻一：中国多地遭雾霾笼罩空气质量再成热议话题
           

          新闻二：民进党台北举行“火大游行”
           

          新闻三：春节临近北京“卖房热”
           

          新闻四：春节临近北京“卖房热”
           

          完成如下要求（共50分，每小题10分）：
           

          1）完成对新闻类的设计，要求在初始化新闻类对象时 ，通过构造传参的形式对新闻标题赋值，并要求实例化四个对象，标题内容如题。
           

          2）要求打印新闻对象时，直接打印新闻标题；
           

          3）要求使用equals方法比较新闻时，只要标题相同，就认为是同一新闻，请输出新闻一与新闻二的比较结果，新闻三与新闻四的比较结果。
           

          4）将新闻对象存入HashSet集合中，并且遍历集合，打印新闻类对象；
           

          5）打印集合中新闻数量。
           

          1. public class Journalism {
          2.     //封装一个新闻类，包含标题、作者、新闻内容和发布时间，
          3.  
          4.     private String title;
          5.  
          6.     private String author;
          7.  
          8.     private String details;
          9.  
          10.     private Date date;
          11.  
          12.     public Journalism() {
          13.     }
          14.  
          15.     public Journalism(String title) {
          16.         this.title = title;
          17.     }
          18.  
          19.     public String getTitle() {
          20.         return title;
          21.     }
          22.  
          23.     public void setTitle(String title) {
          24.         this.title = title;
          25.     }
          26.  
          27.     public String getAuthor() {
          28.         return author;
          29.     }
          30.  
          31.     public void setAuthor(String author) {
          32.         this.author = author;
          33.     }
          34.  
          35.     public String getDetails() {
          36.         return details;
          37.     }
          38.  
          39.     public void setDetails(String details) {
          40.         this.details = details;
          41.     }
          42.  
          43.     public Date getDate() {
          44.         return date;
          45.     }
          46.  
          47.     public void setDate(Date date) {
          48.         this.date = date;
          49.     }
          50.  
          51.     @Override
          52.     public String toString() {
          53.         return "标题：" + title +
          54.                 "\n作者：" + author +
          55.                 "\n内容：" + details +
          56.                 "\n发布时间：" + date ;
          57.     }
          58.  
          59.     //要求使用equals方法比较新闻时，只要标题相同，就认为是同一新闻
          60.  
          61.     @Override
          62.     public boolean equals(Object o) {
          63.         if (this == o) return true;
          64.         if (o == null || getClass() != o.getClass()) return false;
          65.  
          66.         Journalism that = (Journalism) o;
          67.  
          68.         return title != null ? title.equals(that.title) : that.title == null;
          69.     }
          70.  
          71.     @Override
          72.     public int hashCode() {
          73.         return title != null ? title.hashCode() : 0;
          74.     }
          75. }
           

          1. public class Test {
          2.     public static void main(String[] args) {
          3.         //创建HashSet集合对象
          4.         Set set = new HashSet();
          5.  
          6.         //要求在初始化新闻类对象时 ，通过构造传参的形式对新闻标题赋值，并要求实例化四个对象，标题内容如题。
          7.         Journalism journalism1 = new Journalism("中国多地遭雾霾笼罩空气质量再成热议话题");
          8.         Journalism journalism2 = new Journalism("民进党台北举行“火大游行“");
          9.         Journalism journalism3 = new Journalism("春节临近北京“卖房热”");
          10.         Journalism journalism4 = new Journalism("春节临近北京“卖房热”");
          11.  
          12.         //将新闻对象存入HashSet集合中
          13.         set.add(journalism1);
          14.         set.add(journalism2);
          15.         set.add(journalism3);
          16.         set.add(journalism4);
          17.  
          18.         //要求打印新闻对象时，直接打印新闻标题；
          19.         for (Journalism journalism : set){
          20.             System.out.println(journalism);
          21.             System.out.println("------------------------");
          22.         }
          23.  
          24.         //只要标题相同，就认为是同一新闻，请输出新闻一与新闻二的比较结果，新闻三与新闻四的比较结果
          25.         System.out.println("新闻一与新闻二的比较结果:"+journalism1.equals(journalism2));
          26.         System.out.println("新闻三与新闻四的比较结果:"+journalism3.equals(journalism4));
          27.  
          28.         //打印集合中新闻数量
          29.         System.out.println("集合中新闻数量:"+set.size());
          30.     }
          31. }
           

           

           

           

          按要求完成如下操作 
           

          1. 生成10个随机数，值在100到200之间；
          2. 将这十个数存入HashSet集合中（有可能集合的长度小于10）。
          3. 将这个HashSet集合转换成ArrayList集合
          4. 重新为ArrayList集合排序，按照从小到大的顺序；
          5. 使用foreach遍历集合；
           

          1.  @Test
          2.     public void test4() {
          3.         HashSet hashset = new HashSet();
          4.         Random random = new Random();
          5.  
          6.         for (int i = 0; i < 10; i++) {
          7.             int j = random.nextInt(100) + 101;
          8.             hashset.add(j);
          9.         }
          10.         System.out.println(hashset);
          11.  
          12.         ArrayList list = new ArrayList(hashset);
          13.         list.sort(Comparator.naturalOrder());
          14.         list.forEach(integer -> {
          15.             System.out.print(integer + " ");
          16.         });
          17.     }
           

           

           

           

          按要求完成如下操作
           

          1 ）封装一个汽车类，包含String  name、int  speed属性，在测试类中实例化三个对象：c1，c2，c3，分别设置name为：“奥拓”，“宝马”，“奔驰”，速度分别设置为：100,200,300
           

          2 ）使用Map集合对象m1将这三个汽车类对象保存成key，然后将int型的汽车价钱作为值保存在m1的value中，上述三款汽车分别对应的价钱是10000,500000,2000000
           

          3 ）遍历m1的键，打印name属性
           

          4 ）通过合适的方法，求出m1中“宝马”的价格，并打印结果；
           

          5 ）经过折旧，所有汽车都降价到原来的80%，请打印降价后“宝马”的价格
           

          1.    @Test
          2.     public void test6() {
          3.         //在测试类中实例化三个对象：c1，c2，c3，
          4.         //分别设置name为：“奥拓”，“宝马”，“奔驰”，速度分别设置为：100,200,300
          5.         Car c1 = new Car("奥拓", 100);
          6.         Car c2 = new Car("宝马", 200);
          7.         Car c3 = new Car("奔驰", 300);
          8.  
          9.         //2 ）使用Map集合对象m1将这三个汽车类对象保存成key
          10.         HashMap hashMap = new HashMap<>();
          11.  
          12.         //然后将int型的汽车价钱作为值保存在m1的value中,上述三款汽车分别对应的价钱是10000,500000,2000000
          13.         hashMap.put(c1, 10000);
          14.         hashMap.put(c2, 500000);
          15.         hashMap.put(c3, 2000000);
          16.  
          17.         //3 ）遍历m1的键，打印name属性
          18.         Set keySet = hashMap.keySet();
          19.         int i = 1;
          20.         for (Car car : keySet) {
          21.             System.out.print("car" + i++ + "name:" + car.getName() + "   ");
          22.         }
          23.  
          24.         for (Car car : keySet) {
          25.             //4 ）通过合适的方法，求出m1中“宝马”的价格，并打印结果；
          26.             if (car.getName().equals("宝马")) {
          27.                 int price = hashMap.get(car);
          28.                 System.out.println("\n宝马价格为：" + price);
          29.             }
          30.             //5 ）经过折旧，所有汽车都降价到原来的80%，请打印降价后“宝马”的价格
          31.             double price1 = hashMap.get(car) - (hashMap.get(car) * 0.2);
          32.             hashMap.put(car, (int) price1);
          33.         }
          34.         //请打印降价后“宝马”的价格
          35.         for (Car car : keySet) {
          36.             if (car.getName().equals("宝马")) {
          37.                 int price = hashMap.get(car);
          38.                 System.out.println("宝马价格为：" + price);
          39.             }
          40.         }
          41.     }
           

           

           

           

          以下代码的运行结果？
           

          1. public static void main(String[] args) {
          2.     Integer[] datas = {1,2,3,4,5};
          3.     List list = Arrays.asList(datas);
          4.     list.add(5);
          5.     System.out.println(list.size());
          6. }
           

          运行异常，不允许添加元素
           

           

           

           

           

           
 
          结语
           
 
           
 
          本人会持续更新文章的哦！希望大家一键三连，你们的鼓励就是作者不断更新的动力
           
 
           

          
                
                    
                

                
        24. 

                    相关阅读:
          
                    
MaxCompute实例相关操作                            
          
windows10/11子系统安装ubuntu22.04                            
          
ardupilot 高度控制器核心部分---》水平位置为什么不采用三级PID控制                            
          
C# 迭代器                            
          
07【MyBatis连接池与事务管理】                            
          
YOLOV1学习笔记                            
          
pytorch学习------数据集的使用方式                            
          
Tomcat - mac - 部署web项目                            
          
Android apkanalyzer简介                            
          
python pandas.DataFrame 直接写入Clickhouse                            
          
                              
                
          25. 
                
        25. 
                    原文地址：https://blog.csdn.net/qq_34025246/article/details/128160105
                
          26.