java学习记录十一：java内部类：String、StringBuilder和ArrayList

水深无声 2021-09-08 10:50 226阅读 0赞

### java学习记录十一：java内部类String、StringBuilder和ArrayList ###

*  一、String类
 *   *  一、解释
     *  二、String类构造方法
     *   *  1、空参构造方法
         *  2、有参构造方法
     *  三、使用注意点
     *  四、new创建对象和直接赋值创建对象的区别
     *  五、String类的特点
     *  六、字符串的比较方法
     *   *  1、==号
         *  2.equals方法
         *  3.equalsIgnoreCase 方法
     *  七、String类获取功能的方法
     *   *  1.获取字符串的长度方法
         *  2.将指定的字符串连接到该字符串的末尾，拼接
         *  3.返回指定索引处的 char值。
         *  4.返回指定子字符串第一次出现在该字符串内的索引。
         *  4.返回从指定索引位置查找,该子字符串第一次出现在该字符串内的索引。
         *  5 .返回指定子字符串最后一次出现在该字符串内的索引
         *  6.返回从指定索引位置查找,该子字符串最后一次出现在该字符串内的索引
         *  7.返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
         *  8.返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
     *  八、String类判断方法
     *   *  1.判断字符串是否为空,不是判断是不是null,(空的话长度为0返回true，不为0返回false)
         *  2.判断字符串中是否包含 给定的字符串
         *  3.判断字符串是否以 给定的字符串 结尾。
         *  4.判断字符串是否以 给定的字符串 开头
     *  九、String类的转换功能
     *   *  1.用新内容替代旧内容，返回新的字符串
         *  2.把字母都转成其对应的小写形式。
         *  3.把字母都转成其对应的大写形式。
         *  4.把字符串转换为字节数组
         *  5.把字符串转换为数组
         *  6.移除首尾空格
         *  7.根据给定的内容，切割字符串，返回字符串数组
 *  二、StringBuilder类
 *   *  一、解释
     *  二、构造方法
     *   *  1.无参构造方法
         *  2.有参构造方法
     *  三、StringBuilder类拼接和反转方法
     *   *  1.拼接数据，并返回对象本身
     *  四、StringBuilder和String相互转换
     *   *  1.String转换为StringBuilder
         *  2.StringBuilder转换为String
 *  三、集合
 *   *  一、解释
 *  四、ArrayList类
 *   *  一、解释
     *  二、写法
     *  三、ArrayList类构造方法
     *  四、ArrayList类添加元素方法
     *   *  1.将指定的元素追加到此集合的末尾
         *  2.在此集合中的指定位置插入指定的元素
         *  3.插入元素的注意事项
     *  五、ArrayList类常用方法
     *   *  1.删除指定的元素，返回删除是否成功
         *  2.删除指定索引处的元素，返回被删除的元素
         *  3.修改指定索引处的元素，返回被修改的元素
         *  4.返回指定索引处的元素
         *  5.返回集合中的元素的个数

# 一、String类 #

## 一、解释 ##

String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！String类是引用类类型。

## 二、String类构造方法 ##

### 1、空参构造方法 ###

///public String() 创建一个空白字符串对象，不含有任何内容
     String str1 = new String();// str1字符串内容: ""

### 2、有参构造方法 ###

//public String(char[] chs)根据字符数组的内容，来创建字符串对象
            char[] chs = { 'a','b','c','d'};
            String str2 = new String(chs);// str2字符串内容:"abcd"
            System.out.println(str2);// abcd
            
    //public String(byte[] bys)根据字节数组的内容，来创建字符串对象
           byte[] bys = { 97,98,99,100,101,102};
            String str4 = new String(bys);// str4字符串内容:"abcdef"
            System.out.println(str4);// abcdef
    
    //public String(byte[] bytes, int offset, int length)根据指定字节数组范围的内容，来创建字符串对象
           String str5 = new String(bys, 2, 3);// str5字符串内容:"cde"
            System.out.println(str5);// cde
    
     // 直接赋值的方式创建字符串对象
            String str6 = "abc";// str6字符串内容:"abc"
            System.out.println(str6);

## 三、使用注意点 ##

*  静态方法一般我们是通过类名调用，省略创建对象，非静态方法，一般是创建对象调用。
 *  直接赋值两个相同值的对象是同一个引用地址，new创建的两个相同的对象不是同一个引用地址。

## 四、new创建对象和直接赋值创建对象的区别 ##

char[] chs = { 'a','b','c'};
    String s1 = new String(chs);// s1字符串的内容: abc
    String s2 = new String(chs);// s2字符串的内容: abc
     System.out.println(s1 == s2);// 比较s1和s2的地址值 false
    // 上面的代码中,JVM首先会先创建一个字符数组,然后每一次new的时候都会有一个新的地址,只不过s1和s2参考的字符串内容是相同的
    
           String str3 = "abc";// str1字符串的内容: abc
            String str4 = "abc";// str2字符串的内容: abc
            System.out.println(str3 == str4);// 比较str1和str2的地址值 true
    // 上面的代码中,针对第一行代码,JVM会建立一个String对象放在字符串池中,并给s3参考;第二行代码,则让s4直接参考字符串池中String对象,也就是说他们本质上是同一个对象

## 五、String类的特点 ##

*  String类的字符串不可变，它们的值在创建后不能被更改

String s1 = "abc";
    s1 += "d";
    System.out.println(s1); // "abcd" 
    // 内存中有"abc"，"abcd","d",3个对象，s1从指向"abc"，改变指向，指向了"abcd"。

*  虽然 String 的值是不可变的，但是它们可以被共享

String s1 = "abc";
    String s2 = "abc";
    // 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

*  字符串效果上相当于字符数组( char\[\] )

//例如： 
    String str = "abc";
    
    //相当于： 
    char[] data = { 'a', 'b', 'c'};     
    String str = new String(data);
    // String底层是靠字符数组实现的,jdk9底层是字节数组。
    
    byte[] bys = { 97,98,99};
    String str = new String(bys);

## 六、字符串的比较方法 ##

### 1、==号 ###

*  比较基本类型比较的是具体的值

int num1 = 10;
    int num2 = 20;
    num1 == num2  ===> 10==20  结果:false

*  比较引用数据类型：比较的是对象地址值

String str1 = new String("abc");
    String str2 = new String("abc");
    str1 == str2 ===> str1存储的对象地址值 == str2存储的对象地址值  结果: false

### 2.equals方法 ###

*  字符串是对象,它比较内容是否相同,是通过一个方法来实现的,就是equals()方法

//public boolean equals(Object s) 比较两个字符串内容是否相同、区分大小写
    public class StringDemo02 { 
        public static void main(String[] args) { 
            //构造方法的方式得到对象
            char[] chs = { 'a', 'b', 'c'};
            String s1 = new String(chs);
            String s2 = new String(chs);
    
            //直接赋值的方式得到对象
            String s3 = "abc";
            String s4 = "abc";
    
            //比较字符串内容是否相同
            System.out.println(s1.equals(s2));// true
            System.out.println(s1.equals(s3));// true
            System.out.println(s3.equals(s4));// true
        }
    }

### 3.equalsIgnoreCase 方法 ###

equalsIgnoreCase 方法将此字符串与指定对象进行比较，忽略大小写。

public static void main(String[] args) { 
            // public boolean equalsIgnoreCase (String anotherString)
            // 1.创建一个字符串对象
            String str1 = "hello";
    
            // 2.创建一个字符串对象
            String str2 = "Hello";
    
            // 3.使用equalsIgnoreCase()方法比较str1和str2字符串是否相等
            boolean res1 = str1.equalsIgnoreCase(str2);
            System.out.println("res1的值是:"+res1);// true
        }

## 七、String类获取功能的方法 ##

### 1.获取字符串的长度方法 ###

//public int length () ：返回此字符串的长度。
       // 创建字符串对象
            String str = "hello-world!";
            // 获取字符串的长度(字符串的字符个数)
            int len = str.length();
            System.out.println("str的字符串长度是:"+len);// 12

### 2.将指定的字符串连接到该字符串的末尾，拼接 ###

//public String concat (String str) ：将指定的字符串连接到该字符串的末尾。拼接
            String str = "hello-world!";
           // str字符串末尾拼接上hello-itheima
            String newStr = str.concat("hello-itheima");
            System.out.println("拼接后的字符串:"+newStr);// hello-world!hello-itheima

### 3.返回指定索引处的 char值。 ###

//public char charAt (int index) ：返回指定索引处的 char值。
            String str = "hello-world!";
            // 获取str中索引为1的字符
            char ch = str.charAt(1);
            System.out.println("索引为1的字符:"+ch);// e

### 4.返回指定子字符串第一次出现在该字符串内的索引。 ###

//public int indexOf (String str)
          String str1 = "hello-world-hello-itheima-hello-java-hello-itcast";
           // 查找hello第一次出现的索引位置
            int index1 = str1.indexOf("hello");
            System.out.println("hello第一次出现的索引位置:"+index1);// 0

### 4.返回从指定索引位置查找,该子字符串第一次出现在该字符串内的索引。 ###

//public int indexOf(String str, int fromIndex)
      String str1 = "hello-world-hello-itheima-hello-java-hello-itcast";
         // 查找hello第一次出现的索引位置
            int index1 = str1.indexOf("hello");
            System.out.println("hello第一次出现的索引位置:"+index1);// 0
             // 查找hello第二次出现的索引位置
            int index2 = str1.indexOf("hello", index1+1);
            System.out.println("hello第二次出现的索引位置:"+index2);// 12

### 5 .返回指定子字符串最后一次出现在该字符串内的索引 ###

//public int lastIndexOf(String str)
    // 查找hello最后一次出现的索引位置
           String str1 = "hello-world-hello-itheima-hello-java-hello-itcast";
            int lastIndex1 = str1.lastIndexOf("hello");
            System.out.println("hello最后一次出现的索引位置:"+lastIndex1);// 37

### 6.返回从指定索引位置查找,该子字符串最后一次出现在该字符串内的索引 ###

//public int lastIndexOf(String str, int fromIndex)
          String str1 = "hello-world-hello-itheima-hello-java-hello-itcast";
         // 查找hello最后一次出现的索引位置
            int lastIndex1 = str1.lastIndexOf("hello");
            System.out.println("hello最后一次出现的索引位置:"+lastIndex1);// 37
    
            // 查找hello倒数第二次出现的索引位置
            int lastIndex2 = str1.lastIndexOf("hello", lastIndex1 - 1);
            System.out.println("hello倒数第二次出现的索引位置:"+lastIndex2);// 26

### 7.返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。 ###

//public String substring (int beginIndex)
        String str3 = "hello-world-hello-itheima";
       // 获取world-hello-itheima子字符串
            String subStr1 = str3.substring(6);
            System.out.println("subStr1:"+subStr1);// world-hello-itheima

### 8.返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。 ###

// public String substring (int beginIndex, int endIndex)
     String str3 = "hello-world-hello-itheima";
      // 获取world-hello子字符串
            String subStr2 = str3.substring(6, 17);
            System.out.println("subStr2:"+subStr2);// world-hello

## 八、String类判断方法 ##

### 1.判断字符串是否为空,不是判断是不是null,(空的话长度为0返回true，不为0返回false) ###

//boolean isEmpty()
             String str1 = "";// 空字符串
            String str2 = "a";// 非空字符串
            System.out.println(str1.isEmpty());// true
            System.out.println(str2.isEmpty());// false
            //不可能判断为null,null连方法都调用不了,会报空指针异常

### 2.判断字符串中是否包含 给定的字符串 ###

//boolean contains(CharSequence s);
           //CharSequence 这里是形参多态,形参是接口类型或者抽象类,可以传递该类型的子类对象
           String str3 = "hello-world-hello-heima";
            // 判断str3字符串是否包含指定的子字符串
            System.out.println(str3.contains("heima"));// true
            System.out.println(str3.contains("itcast"));// false

### 3.判断字符串是否以 给定的字符串 结尾。 ###

// boolean endsWith(String s);
          // 判断str3字符串是否以hel开头
            String str3 = "hello-world-hello-heima";
            System.out.println(str3.startsWith("hel"));// true

### 4.判断字符串是否以 给定的字符串 开头 ###

//boolean startsWith(String s)
                    String str3 = "hello-world-hello-heima";
                    System.out.println(str3.startsWith("hea"));// false

## 九、String类的转换功能 ##

### 1.用新内容替代旧内容，返回新的字符串 ###

//String replace(char oldChar,char newChar)//这是字符替换
           //String replace(CharSequence oldStr,CharSequence newStr)这是字符串替换，统一用字符串，字符没必要
           String str = "hello-world-hello-heima";
           // 把hello替换为hi，字符串是不可变的，所以会有一个新的字符串。
           String replaceStr = str.replace("hello", "hi");
           System.out.println("替换后的字符串内容:"+replaceStr);// hi-world-hi-heima
           System.out.println("替换前的字符串内容:"+str);// hello-world-hello-heima

### 2.把字母都转成其对应的小写形式。 ###

// String toLowerCase()
           String str1 = "Hello-World-Hello-Heima";
            // 把str1中的字母全部转换为大写字母
            String s1 = str1.toUpperCase();
            System.out.println(s1);// HELLO-WORLD-HELLO-HEIMA

### 3.把字母都转成其对应的大写形式。 ###

//String toUpperCase()
              String str1 = "Hello-World-Hello-Heima";
            // 把str1中的字母全部转换为大写字母
            String s1 = str1.toUpperCase();
            System.out.println(s1);// HELLO-WORLD-HELLO-HEIMA
             String s2 = str1.toLowerCase();
            System.out.println(s2);// hello-world-hello-heima

### 4.把字符串转换为字节数组 ###

//byte[] getBytes()
                  String str1 = "Hello-World-Hello-Heima";
                  // 把str1字符串转换为字符数组
               char[] arr1 = str1.toCharArray();
                for (int i = 0; i < arr1.length; i++) { 
                 System.out.print(arr1[i]+" ");// H e l l o - W o r l d - H e l l o - H e i m a
            }

### 5.把字符串转换为数组 ###

Char[] toCharArray()
    			     String str1 = "Hello-World-Hello-Heima";
    			   // 把str1字符串转换为字符数组
    				char[] arr1 = str1.toCharArray();
    				for (int i = 0; i < arr1.length; i++) { 
    			    System.out.print(arr1[i]+" ");// H e l l o - W o r l d - H e l l o - H e i m a
    }

### 6.移除首尾空格 ###

//String trim()
         	 // 移除首尾空格
    		String username = " admin ";
    		String trimStr = username.trim();
    		System.out.println("="+trimStr+"=");// =admin=

### 7.根据给定的内容，切割字符串，返回字符串数组 ###

//String[] split(String regex)
            //参数regex: 分割的规则(普通的字符串,也可以是特殊的字符串(正则表达式))
            String str2 = "Hello-World-Hello-Heima";
            // 以-对str2进行分割
            String[] arr = str2.split("-");
            for (int i = 0; i < arr.length; i++) { 
                System.out.println(arr[i]);
            }
             String str3 = "Hello.World.Hello.Heima";
            // 以.对str3进行分割
            String[] arr3 = str3.split("\\.");// .特殊字符串(正则表达式),而在正则表达式中点表示任意字符
            for (int i = 0; i < arr3.length; i++) { 
                System.out.println(arr3[i]);
            }

String对象内容不可变,所以每次拼接都是创建一个新的字符串对象  
而StringBuilder对象是直接在后面拼接,节省了内存空间.

# 二、StringBuilder类 #

## 一、解释 ##

由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象,在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。由此可知，如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，**既耗时，又浪费空间**。为了解决这一问题，可以使用`java.lang.StringBuilder`类。StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的

## 二、构造方法 ##

### 1.无参构造方法 ###

//public StringBuilder() 创建一个空白可变字符串对象，不含有任何内容
      // 创建空白可变字符串对象 ""
            StringBuilder sb1 = new StringBuilder();
            System.out.println("sb1:"+sb1+"=");// sb1:=
            System.out.println("sb1的长度:"+sb1.length());// 0

### 2.有参构造方法 ###

//public StringBuilder(String str) 根据字符串的内容，来创建可变字符串对象
           // 把不可变字符串转换为可变字符串
            String str = "itheima";// 不可变的字符串
            StringBuilder sb2 = new StringBuilder(str);// 可变的字符串,字符串内容是:itheima
            System.out.println("sb2:"+sb2);// sb2:itheima
            System.out.println("sb2的长度:"+sb2.length());// 7

## 三、StringBuilder类拼接和反转方法 ##

### 1.拼接数据，并返回对象本身 ###

//public StringBuilder append(任意类型) 拼接数据，并返回对象本身
    	// 创建可变字符串对象
    	StringBuilder sb1 = new StringBuilder("hello");
    
    	// sb1字符串末尾拼接上"-world"
    	StringBuilder sb2 = sb1.append("-world");
    	System.out.println(sb1);// hello-world
    	System.out.println(sb2);// hello-world
    	System.out.println(sb1==sb2);// sb1和sb2的地址值是一样的,true
    
    	//public StringBuilder insert(int offset, 任意类型) 在指定位置插入数据,并返回对象本身
           // 把-java插入到sb1可变字符串中,使得sb1为:hello-java-world
            sb1.insert(5,"-java");
            System.out.println(sb1);// hello-java-world
    
         // public StringBuilder reverse() 反转字符串,并返回对象本身
         // 把sb1中的字符串内容进行反转
            StringBuilder sb3 = sb1.reverse();
            System.out.println(sb1);// dlrow-avaj-olleh
            System.out.println(sb3);// dlrow-avaj-olleh
            System.out.println(sb1==sb3);// true

## 四、StringBuilder和String相互转换 ##

### 1.String转换为StringBuilder ###

//public StringBuilder(String s)`：通过StringBuilder的构造方法就可以实现把 String 转换为 
        String str = "hello-world";
        StringBuilder sb = new StringBuilder(str);

### 2.StringBuilder转换为String ###

//public String toString()：通过StringBuilder类中的 toString() 就可以实现把 StringBuilder 转换为 String
            String str = "hello-world";
           StringBuilder sb = new StringBuilder(str);
            String s = sb.toString();
            System.out.println(sb);// hello-world 可变字符串
            System.out.println(s);// hello-world 不可变的字符串

# 三、集合 #

## 一、解释 ##

编程的时候如果要存储多个数据,首先我们想到的就是数组,但是数组的特点是长度固定,所以数组不一定能满足我们的需求,更适应不了变化的需求,这时候就需要集合，集合其实就是一个大小可变的容器,可以用来存储多个引用数据类型的数据。

# 四、ArrayList类 #

## 一、解释 ##

ArrayList类是集合的一种，该类在java.util.ArrayList \` ：需要 import导入使后使用。 表示一种未知的数据类型,叫做泛型,用于约束集合中存储元素的数据类型，且E只能填写引用数据类型，引用数据类型就是类，接口或者数组。ArrayList类底层是大小可变的数组的实现，存储在内的数据称为元素。也就是说ArrayList 中可以不断添加元素，其大小会自动增长。

## 二、写法 ##

ArrayList<String> 表示ArrayList集合中只能存储String类型的对象
    ArrayList<Student> 表示ArrayList集合中只能存储Student类型的对象
    ArrayList<int> 编译报错,因为E这个位置只能写引用数据类型

## 三、ArrayList类构造方法 ##

//public ArrayList() 构造一个初始容量为 10 的空列表。
           // 创建ArrayList集合对象,限制集合中元素的类型为String类型
            ArrayList<String> list1 = new ArrayList<String>();
            ArrayList<String> list2 = new ArrayList<>();//可以省后面的String
               
           // 创建ArrayList集合对象,限制集合中元素的类型为Student类型
            ArrayList<Student> list3 = new ArrayList<>();
            // 创建ArrayList集合对象,限制集合中元素的类型为int类型
            //ArrayList<int> list4 = new ArrayList<int>();// 编译报错
            // 集合中存储基本数据类型
            // 创建ArrayList集合对象,限制集合中元素的类型为Integer类型
            ArrayList<Integer> list5 = new ArrayList<>();// 存储int类型的数据
    
            // 创建ArrayList集合对象,不限制集合中元素的类型
            ArrayList list6 = new ArrayList();// 存储任意类型的对象
              
                      //不能填基本类型，要填对应的包装类型
                      //基本数据类型 对应 包装类类型
                        byte                                    Byte
                        short                                   Short
                        int                                     Integer
                        long                                    Long
                        float                                   Float
                        double                                  Double
                        boolean                                 Boolean
                        char                                    Character

## 四、ArrayList类添加元素方法 ##

### 1.将指定的元素追加到此集合的末尾 ###

//public boolean add(E e)：将指定的元素追加到此集合的末尾
           // 创建ArrayList集合,限制集合中元素的类型为String类型
        ArrayList<String> list = new ArrayList<>();
        // 往list集合中添加元素
        list.add("你");
        list.add("我");
        list.add("它");
        System.out.println(list);// [你, 我,它]

### 2.在此集合中的指定位置插入指定的元素 ###

//public void add(int index,E element)：在此集合中的指定位置插入指定的元素
    	 // 把他插入在索引为1的位置
    	    list.add(1,"他");
     	    System.out.println(list);// [你, 他, 我, 它]

### 3.插入元素的注意事项 ###

// 创建ArrayList集合对象,限制集合中元素的类型为Integer类型
            ArrayList<Integer> list = new ArrayList<>();
    
            // 往集合中添加元素
            list.add(10);//这里其实发生了自动装箱，int类型的10包装成了integer类型的了。
            list.add(20);
            list.add(30);
            list.add(40);
            System.out.println("list:"+list);// list:[10, 20, 30, 40]
    
            // 思考一:指定索引为4的位置添加一个元素50,是否可以?---可以
            list.add(4,50);// 相当于list.add(50);
            System.out.println("list:"+list);// list:[10, 20, 30, 40, 50]
    
            // 思考二:指定索引为6的位置添加一个元素100,是否可以?----不可以
            //list.add(6,100);// 运行报异常,IndexOutOfBoundsException索引越界异常

## 五、ArrayList类常用方法 ##

### 1.删除指定的元素，返回删除是否成功 ###

//public boolean remove(Object o) 删除指定的元素，返回删除是否成功
    	// 创建ArrayList集合,限制集合中元素的类型为String类型
    	ArrayList<Integer> list = new ArrayList<>();
    	// 往list集合中添加元素
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list);// [1, 2, 3]
           boolean res1 = list.remove((new Integer(1));//这里删除数字时需要传入1的integer对象
            System.out.println("是否删除成功:"+res1);// true
             System.out.println(list);// [2, 3]

### 2.删除指定索引处的元素，返回被删除的元素 ###

//public E remove(int index) 删除指定索引处的元素，返回被删除的元素
      ArrayList<Integer> list = new ArrayList<>();
    	// 往list集合中添加元素
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list);// [1, 2, 3]
            Integer removeE = list.remove(1);//2

### 3.修改指定索引处的元素，返回被修改的元素 ###

//public E set(int index, E element) 修改指定索引处的元素，返回被修改的元素
    ArrayList<Integer> list = new ArrayList<>();
    	// 往list集合中添加元素
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list);// [1, 2, 3]
            Integer setE = list.set(0, 4);//1

### 4.返回指定索引处的元素 ###

//public E get(int index) 返回指定索引处的元素
           ArrayList<Integer> list = new ArrayList<>();
    	// 往list集合中添加元素
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list);// [1, 2, 3]
               Integer e = list.get(0);
            System.out.println("索引为0的元素:"+e);// 1

### 5.返回集合中的元素的个数 ###

public int   size() 返回集合中的元素的个数
        ArrayList<Integer> list = new ArrayList<>();
    	// 往list集合中添加元素
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list);// [1, 2, 3]
            int size = list.size();
       System.out.println("集合中元素的个数:"+size);// 3