Java学习笔记41：List,Map集合框架知识整理（附代码说明）

水深无声 2022-03-29 02:38 71阅读 0赞

原文章出处：[https://www.cnblogs.com/kehuaihan/p/6759988.html][https_www.cnblogs.com_kehuaihan_p_6759988.html]

**Collection集合常用方法：**

增加  add(E o);  
    删除  boolean remove(Object o);  
    大小  int size();  
    包含  boolean contains(Object o);  
    为空  boolean isEmpty();  
    清空  void clear();  
    迭代  Iterator<E> iterator();
    并交差
      boolean addAll(Collection c);  
      boolean retainAll(Collection c);  
      boolean removeAll(Collection c);

**Set集合常用的方法：**

与Collection集合拥有的方法一样；

**List集合常用的方法：**

> List集合的方法中，带索引参数（角标）的都是新增的方法；  
> 带角标的操作都是数组原理；

除了继承Collection集合的方法，还有以下自己独有的方法，都与索引（下标）有关：

> 增加、删除、修改（只能是修改，不能是插入）、查找（获取）元素、查找元素所在位置（两种）；
> 
> void add(int index, E e);  
> E remove(int index);  
> E set(int index, Ee); //修改，不能插入  
> E get(int index);  
> int indexOf(Object o); //查找位置  
> int lastIndexOf(Objecto);

**Map集合常用的方法：**

> 增加、删除、修改、查找（获取）、大小、包含、为空、清空、迭代
> 
> V put(K k, V v);  
> V remove(Object k);  
> put()方法也起到修改功能  
> Vget(Object k);  
> int size();  
> boolean containsKey(Object k);  
> boolean containsValue(Object v);  
> boolean isEmpty();  
> void clear();

为什么会有集合；       
         为什么会有这么多不同的集合框架；  
         集合与数组的区别；         
         集合类的关系图；`
    
     集合中存放的是对象实体还是对象的引用（地址），并想一下内存图；
     集合中取出元素并操作的常用方法；  
       集合中获取所有元素的常用方法；
       
       Collection接口的常见两个子接口及比较；
       
       List接口下的常用类及比较；
       
       List集合独有的迭代器；
       
       Vector特有的迭代器（枚举）；
       
       LinkedList中一些方法的版本迭代；
       
       List集合中如何实现去除重复元素；
       
       Set接口下的常用类及比较；
       
       Set集合中，如何实现去除重复元素；
       
       Set集合中，如何实现对元素进行排序；（应该不是只针对TreeSet集合）；
       
       泛型；
       
       Map集合下的常用类；
       
       Map集合取出元素的方法；
       
       集合框架中的工具类；
       
       增强型for循环；

*  **为什么会有集合：**

> `数据多了，用对象存；对象多了，用集合（和数组）存；`

*  **为什么会有这么多不同的集合框架（容器）：**

> `因为每个容器对数据的存储方式都有不同；存储方式就是指数据结构；`

*  **集合与数组的区别：**

>     数组的长度是固定的，集合的长度是可变的；
>     
>      数组只能存储同一类型数据，集合能存储不同类型数据；
>     
>      **数据可以存基本类型数据，集合只能存对象；**

*  **集合框架的关系图：**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwMjQyOTg3_size_16_color_FFFFFF_t_70]

*  **集合中存放的是对象实体还是对象的引用（地址）？**
    
    集合中存放的都是对象的引用（地址）；
 *  **集合中取出元素并操作的常用方法：**

>     使用迭代器：就是集合中取出元素的一种方式；
>     
>       有的接口（实现类）有专门的取出元素的方法：
>     
>       List集合中：get(index)  subList(from,to)  Iterator

*  **集合中获取所有元素的常用方法：**

>     for循环
>     
>       加强型for循环
>     
>       迭代器

*  **Collection接口的常见两个子接口及比较：**

>     List接口：
>     
>       元素是有序的，元素可以重复，因为有索引；
>     
>      Set接口：
>     
>       元素是无序的（存入和取出的顺序不一定一致），元素不可以重复；

*  **List接口下的常用类及比较**：

>     ArrayList：底层的数据结构使用的是数组结构； 
>      特点：查询元素速度很快，但增删稍慢；  **线程不同步**
>     
>     LinkedList：底层的数据结构使用的是链表结构；  
>     特点：增删速度很快，但查询稍慢；
>     
>     Vector：底层的数据结构使用的是数组结构；  
>     特点：查询，增删速度都很慢，被ArrayList替换了；  **线程同步**
>     
>     java集合框架还专门提供加锁的功能，把你不安全的给我，我给你安全的，解决线程不同步问题；

*  **List集合独有的迭代器：**

>     ListIterator（接口），继承自Iterator接口；
>     
>       使用迭代器过程中，有两种操作元素的方式：
>      
>          使用集合对象的方法操作元素；
>           使用迭代器的方法操作元素；
>     
>       在迭代时，不可以用集合对象的方法操作集合中的元素，因为会发生并发修改异常；
>       要用迭代器自己的方法操作数据；
>     
>       Iterator接口只有删除元素的操作，而ListIterator接口有增加、删除、修改等操作；（实例中有疑问）

*  **Vector特有的迭代器（枚举）：**

**已经被Iterator替代，因为它的功能和Iterator一样，  
但它的名称和它的方法名过长，没有Iterator好使；**

*  **LinkedList中一些方法的版本迭代：**

>     - [ ] JDK1.6之前：
>     
>       addFirst()、addLast()：添加元素
>     
>       getFirst()、getLast()：获取元素，但不删除元素；如果集合中没有元素，会抛出NoSuchElementException
>     
>       removsFirst()、removeLast()：获取元素，但同时元素也被删除；如果集合中没有元素，会抛出NoSuchElementException
>     
>      - [ ] JDK1.6之后：
>     
>       offerFirst()、offerLast()：添加元素
>     
>       peekFirst()、peekLast()：获取元素，但不删除元素；如果集合中没有元素，返回null
>     
>       pollFirst()、pollLast()：获取元素，但同时元素也被删除；如果集合中没有元素，返回null

*  **获取所有元素并删除的实现：**

> \*\*使用迭代器；
> 
> 使用 pollFirst()、pollLast()方法：\*\*
> 
>     while( ! link.isEmpty() )
>     
>       {
>     
>           syso(link.pollFirst());
>     
>       }

*  **List集合中判断元素是否相同的问题：**

>     集合中有自己的判断元素的方法，但不符合需求的话，就要程序员自己定义判断规则；
>     
>       集合自身只能判断对象是否相同，用equals()方法来判断:obj1.equals(obj2)；而继承自Object类的equals()方法是判断对象是否相同时判断的是对象的地址是否相同；
>       但如果具体判断对象的属性值是否相同时，equals()方法就相当于判断对象的内容而不是地址是否相同的（其实此时用的是String类中的判断字符串内容是否相同的方法，已经重写的继承自Object类的equals()方法）；
>     
>       List集合中的contains()、remove()两个方法底层都是用equals()方法来实现的；
>     
>       程序员自己通过修改继承自Object类的equals()方法来自定义判断规则，使自定义类具体可比较性；

*  **Set集合的两个子类：**

>     HashSet：底层的数据结构使用的是Hash表；
>     
>     TreeSet：底层数据结构是二叉树；
>     可以对Set集合中的元素进行排序，以自然顺序进行排序；

*  **HashSet是如何保证元素唯一性的：**

>     是通过元素的两个方法：hashCode()和equals()；
>     
>     如果元素的hashCode值相同，才会调用equals()判断是否为true；
>     
>     如果元素的hashCode值不同，不会调用equals()判断是否为true；
>     
>     注意：对于判断元素是否存在，以及元素删除等操作，
>     依赖的方法是元素的hashCode()和equals()方法，
>     先使用hashCode()；
>     
>     **ArrayList只依赖equals()方法；**
>     
>     所以开发中，往集合中添加元素时，一般都会覆写hashCode()和equals()方法；

*  **TreeSet集合对元素进行排序:**

>     TreeSet保证元素唯一性：依靠compareTo()方法返回值；
>     
>       TreeSet集合本身会对元素进行按自然顺序进行排序，
>       但在实际开发中肯定不满足需求，需要程序员自定义排序规则；
>     
>       元素被放入TreeSet集合之前，必须是可以被排序的
>       （告诉TreeSet集合如何排序），不然程序运行时会报错；
>       或者元素不具备比较性，然TreeSet集合本身实现需要的比较规则也可以；

*  **TreeSet集合的两种排序方式：**

>     第一种：当元素不具备比较性，强制使元素具备比较性，继承Comparable接口；
>     
>     第二种：当元素不具备比较性，或者元素具备的比较性不是所需要的，
>     实现让集合本身具备比较性；
>     实现：在集合初始化时，就具有比较性，所以是对构造函数进行改造；
>     
>     注意：
>     
>       当两种排序都存在时，以比较器（Comparator）为准；
>     
>       排序时，当主要条件相等时，必须要再判断次要条件，直到能排除一个顺序出来；

*  **泛型：**

JDK1.5之后出现的泛型，解决安全问题，是一种安全机制；

好处：

将运行时期出现的类型转换异常转移到了编译时期，方便于程序员解决问题，
    让运行时期出现问题较少；
    
    避免了强制转换的麻烦；

*  **什么时候使用泛型：**

>     通常在集合框架中很常见；
>     
>         只要见到<>就要定义泛型；
>     
>       其实<>就是用来接收类型的，当使用集合时，
>       将集合中要存储的数据类型作为参数传递到<>中即可；

*  **什么时候使用泛型类：**

>     当类中要操作的引用数据类型不确定的时候使用泛型类；
>     
>       早期通过定义Object来完成扩展，现在通过定义泛型来完成扩展；
>     
>       方法删规定以泛型比类上定义泛型扩展性更好；
>     
>       当类上个方法上都定义泛型时，并不冲突，以方法上定义的泛型为准；
>     
>       泛型类上定义的泛型，在整个类中有效，如果被方法使用，
>       
>       那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了；
>       
>       为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上；
>       
>       注意：静态方法不可以访问类上定义的泛型，
>       
>       所以如果静态方法操作的引用数据类型不确定的话，可以将泛型定义在静态方法上；

*  **泛型的限定：**

>     ? extends E：可以接收E类型或者E的子类型，上限；
>     
>     ? super E：可以接收E类型或者E的父类，下限；

*  **Map集合下的常用类：**

>     HashTable：
>     底层的数据结构使用的是哈希表；
>      不可以存入null键null值； 
>      该集合是线程同步的；  
>      效率低；
>     
>     HashMap：
>     底层的数据结构使用的是哈希表； 
>     可以存入null键null值；
>      该集合不是线程同步的；  
>      效率高；
>     
>     TreeMap：
>     底层的数据接口使用的是二叉树；
>      线程不同步； 
>      可以用于给Map集合中的键进行排序；

*  **数组变成集合：**

>     将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的；
>     
>     如果数组中的元素都是对象，那么转成集合时，数组中的元素就直接转成集合中的元素；
>     
>     如果数组中的元素都是基本类型，那么会将该数组作为集合中的元素存在；

*  **集合转成数组时，指定类型的数组要定义成多长：**

>     当指定类型数组的长度小于集合的size时，
>     那么该方法的内部会创建一个新的数组，长度为集合的size；
>     当指定类型数组的长度大于集合的size时，
>     该方法不会再创建一个新的数组，而是使用传递过来的数组；
>     所以创建一个刚刚好的数组最优；

*  **为什么要将集合转成数组：**

> 限定对元素的操作；  
> 集合可以增删元素，转成数组之后，就能进行元素增删操作了；

*  **foreach：**

> 只能获取集合中的元素，但不能对集合进行操作；

*  **迭代器：**

>     除了遍历集合元素，还可以进行remove集合中元素的操作；
>     
>     如果使用ListIterator，还可以在遍历元素时候进行增删改查的动作；

*  **for与foreach的区别：**

>     foreach必须有被遍历的目标；
>     
>     方法的可变参数一定要定义在参数列表的最后面；

*  **静态导入：**

>     当类重名时，需要指定具体的包名；
>     
>     当方法重名时，需要制定具体的所属对象或类；

一些实例：

复制代码
     1 /**
     2  * 迭代器的使用
     3  */
     4 package collection;
     5 
     6 import java.util.ArrayList;
     7 import java.util.Iterator;
     8 
     9 public class IteratorDemo
    10 {
    11     public static void main(String[] args)
    12     {
    13         iterator();
    14     }
    15     
    16     public static void iterator()
    17     {
    18         // 现在集合中添加元素
    19         ArrayList al = new ArrayList();
    20         al.add("java1");
    21         al.add("java2");
    22         al.add("java3");
    23         
    24         // 使用迭代器，可以对每一个元素进行操作
    25         // 通过iterator()方法获得Iterator接口的子对象
    26         Iterator it = al.iterator();  
    27         // 判断后面是否还有元素
    28         while(it.hasNext())
    29         {
    30             // 打印出后面这个元素
    31             System.out.println(it.next());
    32         }
    33 
    34          // 另外一种书写方式
    35         // 使用这种方式，迭代器对象使用完之后就被销毁了
    36         for(Iterator it2 = al.iterator(); it2.hasNext(); )
    37         {
    38             System.out.println(it2.next());
    39 }
    40     }
    41 }
    复制代码
     
    
    复制代码
     1 /**
     2  * 功能：List集合特有的迭代器
     3  */
     4 package collection;
     5 
     6 import java.util.ArrayList;
     7 import java.util.Iterator;
     8 import java.util.ListIterator;
     9 
    10 public class IteratorDemo2
    11 {
    12     public static void main(String[] args)
    13     {
    14         // iterator();
    15         listIterator();
    16     }
    17     
    18     public static void iterator()
    19     {
    20         ArrayList al = new ArrayList();
    21         al.add("java1");
    22         al.add("java2");
    23         al.add("java3");
    24         System.out.println(al);
    25         
    26         Iterator it = al.iterator();  
    27         while(it.hasNext())
    28         {
    29             Object obj = it.next();
    30             if(obj.equals("java2"))
    31             {
    32                 // 以下写法是错误的，会产生并发异常
    33                 // 对元素操作，要么全用集合的方法，要么全用迭代器的方法
    34                 // al.add("java4");
    35                 
    36                 // 将java2的引用从集合中删掉
    37                 // 迭代器本身只有这个删除元素方法，比较局限
    38                 it.remove();
    39             }
    40             
    41             // 还是能打印出java2，因为obj还在引用它
    42             System.out.println(obj);
    43         }
    44         
    45         // 打印不出来java2了，因为al对它的引用已经被删掉了
    46         System.out.println(al);
    47     }
    48     
    49     public static void listIterator()
    50     {
    51         ArrayList al = new ArrayList();
    52         al.add("java1");
    53         al.add("java2");
    54         al.add("java3");
    55         System.out.println(al);
    56         
    57         ListIterator lit = al.listIterator();
    58         while(lit.hasNext())
    59         {
    60             Object obj = lit.next();
    61             if(obj.equals("java2"))
    62             {
    63                 // 在java2后面添加一个java4
    64                 lit.add("java4");
    65             }
    66             System.out.println(obj);
    67         }
    68         
    69         System.out.println(al);
    70     }
    71 }
    复制代码
     
    
    复制代码
     1 /**
     2  * 功能：Vector特有的迭代器，枚举 
     3  */
     4 package collection;
     5 
     6 import java.util.Enumeration;
     7 import java.util.Vector;
     8 
     9 public class VectorDemo
    10 {
    11     public static void main(String[] args)
    12     {
    13         Vector vt = new Vector();
    14         vt.add("java1");
    15         vt.add("java2");
    16         vt.add("java3");
    17         
    18         Enumeration<String> ea = vt.elements();
    19         while(ea.hasMoreElements())
    20         {
    21             System.out.println(ea.nextElement());
    22         }
    23     }
    24 }
    复制代码
     
    
    复制代码
     1 /**
     2  * 功能：集合中去除重复元素
     3  */
     4 package collection;
     5 
     6 import java.util.ArrayList;
     7 import java.util.Iterator;
     8 
     9 public class RevDuplElement
    10 {
    11     public static void main(String[] args)
    12     {
    13         ArrayList list = new ArrayList();
    14         list.add("one");
    15         list.add("one");
    16         list.add("two");
    17         list.add("two");
    18         list.add("three");
    19         list.add("three");
    20         
    21         System.out.println(test(list));
    22     }
    23     
    24     public static ArrayList test(ArrayList list)
    25     {
    26         ArrayList newList = new ArrayList();
    27         Iterator it = list.iterator();
    28         while(it.hasNext())
    29         {
    30             Object obj = it.next();
    31             if(!newList.contains(obj))
    32             {
    33                 newList.add(obj);
    34             }
    35         }
    36         return newList;
    37     }
    38 }
    复制代码
     
    
    复制代码
     1 /**
     2  * 功能：向下转型
     3  */
     4 package collection;
     5 
     6 import java.util.ArrayList;
     7 import java.util.Iterator;
     8 
     9 public class Convert
    10 {
    11     public static void main(String[] args)
    12     {
    13         ArrayList<Person3> list = new ArrayList<Person3>();
    14         list.add(new Person3("zhangsan",25));
    15         // add()方法里面的参数对象是Object，所以上面一句涉及到向上转型，具体如下
    16         // Object obj = new Person3("zhangsan",25);
    17          // list.add(obj);
    18         list.add(new Person3("lisi",26));
    19         list.add(new Person3("wangwu",27));
    20         
    21         // 没有使用泛型
    22         Iterator it = list.iterator();
    23         while(it.hasNext())
    24         {
    25             // 下面这样写(在没有使用泛型的情况下)是错误的，因为it.next()返回的对象是Object类型，不是Person3类型
    26             // 所以不会有getName()方法，需要向下转型
    27             // System.out.println("name" + it.next().getName());
    28             
    29             // 正确操作
    30             Person3 person = (Person3) it.next();
    31             System.out.println("name:" + person.getName() + ",age:" + person.getAge());
    32         }
    33         
    34         // 使用泛型
    35         Iterator<Person3> it2 = list.iterator();
    36         while(it2.hasNext())
    37         {
    38             System.out.println("name:" + it2.next().getName());
    39             // 不能这样写，因为每用一次next()都是找后面一个元素，而不是使用当前元素
    40             // System.out.println("name:" + it2.next().getName() + ",age:" + it2.next().getAge());
    41         }
    42     }
    43 }
    44 
    45 class Person3
    46 {
    47     private String name;
    48     private int age;
    49     
    50     public Person3(String name, int age)
    51     {
    52         this.name = name;
    53         this.age = age;
    54     }
    55     
    56     public String getName()
    57     {
    58         return name;
    59     }
    60     public void setName(String name)
    61     {
    62         this.name = name;
    63     }
    64     public int getAge()
    65     {
    66         return age;
    67     }
    68     public void setAge(int age)
    69     {
    70         this.age = age;
    71     }
    72     
    73     @Override
    74     public String toString()
    75     {
    76         return "Person [name=" + name + ", age=" + age + "]";
    77     }
    78     
    79 }
    复制代码
     
    
    复制代码
      1 /**
      2  * 功能：List集合中，重写equals方法，自定义判断规则
      3  * 通过比较，去除集合中相同的元素
      4  */
      5 package collection;
      6 
      7 import java.util.ArrayList;
      8 import java.util.Iterator;
      9 
     10 public class EqualsTest
     11 {
     12     public static void main(String[] args)
     13     {
     14         ArrayList list = new ArrayList();
     15         list.add(new Student4("lisi01", 25));
     16         list.add(new Student4("lisi01", 25));
     17         list.add(new Student4("lisi02", 22));
     18         list.add(new Student4("lisi03", 23));
     19         list.add(new Student4("lisi02", 22));
     20         list.add(new Student4("lisi03", 23));
     21         
     22         list = com(list);
     23         
     24         Iterator it = list.iterator();
     25         while(it.hasNext())
     26         {
     27             Student4 student = (Student4) it.next();
     28             System.out.println(student.getName() + "," + student.getAge());
     29         }
     30     }
     31     
     32     public static ArrayList com(ArrayList list)
     33     {
     34         ArrayList newList = new ArrayList();
     35         Iterator it = list.iterator();
     36         while(it.hasNext())
     37         {
     38             Object obj = it.next();
     39             // contains()底层是用equals()方法来实现的
     40             // 让Studnet4的两个对象使用equals()来比较
     41             // 所以要修改Studnet4的equals()方法
     42             if(!newList.contains(obj))
     43             {
     44                 newList.add(obj);
     45             }
     46         }
     47         
     48         return newList;
     49     }
     50 }
     51 
     52 class Student4
     53 {
     54     private String name;
     55     private int age;
     56     
     57     public Student4(String name, int age)
     58     {
     59         this.name = name;
     60         this.age = age;
     61     }
     62     
     63     // 覆盖继承自Object的equals()
     64     //  形参类型必须是Object，否则不是继承自Object类的方法
     65     public boolean equals(Object obj)
     66     {
     67         // 注意：obj必须放在前面
     68         if(! (obj instanceof Student4))
     69         {
     70             return false;
     71         }
     72         
     73         Student4 student = (Student4) obj;
     74         if(this.name.equals(student.getName()) && this.age==student.getAge())
     75         {
     76             return true;
     77         }
     78         else
     79         {
     80             return false;
     81         }
     82         
     83     }
     84 
     85     public String getName()
     86     {
     87         return name;
     88     }
     89 
     90     public void setName(String name)
     91     {
     92         this.name = name;
     93     }
     94 
     95     public int getAge()
     96     {
     97         return age;
     98     }
     99 
    100     public void setAge(int age)
    101     {
    102         this.age = age;
    103     }
    104     
    105 }
    复制代码
     
    
    复制代码
      1 /**
      2  * 功能：重写hashCode()方法
      3  * Set集合中比较元素首先用hashCode()判断地址是否相等
      4  * 再用equals()判断元素内容是否相等
      5  */
      6 package collection;
      7 
      8 import java.util.HashSet;
      9 import java.util.Iterator;
     10 
     11 public class HashCodeTest
     12 {
     13     public static void main(String[] args)
     14     {
     15         HashSet set = new HashSet();
     16         set.add(new Student5("lisi01",21));
     17         set.add(new Student5("lisi02",22));
     18         set.add(new Student5("lisi03",23));
     19         set.add(new Student5("lisi02",22));
     20         
     21         set = com(set);
     22         
     23         Iterator it = set.iterator();
     24         while(it.hasNext())
     25         {
     26             Student5 student = (Student5) it.next();
     27             System.out.println(student.getName() + "," + student.getAge());
     28         }
     29     }
     30     
     31     public static HashSet com(HashSet set)
     32     {
     33         HashSet newSet = new HashSet();
     34         Iterator it = set.iterator();
     35         while(it.hasNext())
     36         {
     37             Object obj = it.next();
     38             if(!(newSet.contains(obj)))
     39             {
     40                 newSet.add(obj);
     41             }
     42         }
     43         return newSet;
     44     }
     45 }
     46 
     47 class Student5
     48 {
     49     private String name;
     50     private int age;
     51     
     52     public Student5(String name, int age)
     53     {
     54         this.name = name;
     55         this.age = age;
     56     }
     57     
     58     // 重写hashCode()方法
     59     public int hashCode()
     60     {
     61         return name.hashCode() + age;
     62     }
     63     
     64     // 重写equals()方法
     65     public boolean equals(Object obj)
     66     {
     67         if(! (obj instanceof Student5))
     68         {
     69             return false;
     70         }
     71         
     72         Student5 student = (Student5) obj;
     73         if(this.name.equals(student.getName()) && this.age == student.getAge())
     74         {
     75             return true;
     76         }
     77         else
     78         {
     79             return false;
     80         }
     81     }
     82     
     83     public String getName()
     84     {
     85         return name;
     86     }
     87     public void setName(String name)
     88     {
     89         this.name = name;
     90     }
     91     public int getAge()
     92     {
     93         return age;
     94     }
     95     public void setAge(int age)
     96     {
     97         this.age = age;
     98     }
     99     
    100 }
    复制代码
     
    
    复制代码
     1 /**
     2  * 功能：Comparable接口的使用
     3  */
     4 package collection;
     5 
     6 import java.util.Iterator;
     7 import java.util.TreeSet;
     8 
     9 public class TreeSetDemo
    10 {
    11     public static void main(String[] args)
    12     {
    13         treeSetDemo();
    14     }
    15     
    16     public static void treeSetDemo()
    17     {
    18         TreeSet ts = new TreeSet();
    19         ts.add(new Student("t1",11));
    20         // 如果Student类没有实现Comparable接口，多添加下面一条数据就抛异常
    21         // 因为这个类中的数据没有可比较性
    22         ts.add(new Student("t2",12));
    23         ts.add(new Student("t3",13));
    24         
    25         Iterator it = ts.iterator();
    26         while(it.hasNext())
    27         {
    28             Student stu = (Student)it.next();
    29             System.out.println("name:" + stu.getName() + ",age:" + stu.getAge());
    30         }
    31         
    32     }
    33     
    34 }
    35 
    36 // 该接口强制让学生具备比较性
    37 class Student implements Comparable
    38 {
    39     private String name;
    40     private int age;
    41     
    42     public Student(String name, int age)
    43     {
    44         this.name = name;
    45         this.age = age;
    46     }
    47     
    48     @Override
    49     public int compareTo(Object obj)
    50     {
    51         if(!(obj instanceof Student))
    52         {
    53             throw new RuntimeException("不是Student类");
    54         }
    55         
    56         Student stu = (Student)obj;
    57         
    58         if(this.age > stu.age)
    59             return 1;  // 只要返回正数即可
    60         if(this.age == stu.age)
    61         {
    62             // String类型本身也实现了Comparable接口
    63             return this.name.compareTo(stu.name);
    64         }
    65             
    66         return -1;  // 只要返回负数即可
    67     }
    68 
    69     public String getName()
    70     {
    71         return name;
    72     }
    73     
    74     public void setName(String name)
    75     {
    76         this.name = name;
    77     }
    78     
    79     public int getAge()
    80     {
    81         return age;
    82     }
    83 
    84     public void setAge(int age)
    85     {
    86         this.age = age;
    87     }
    88 }
    复制代码
     
    
    复制代码
      1 /**
      2  * 功能：Comparator的使用
      3  */
      4 package collection;
      5 
      6 import java.util.Comparator;
      7 import java.util.Iterator;
      8 import java.util.TreeSet;
      9 
     10 public class TreeSetDemo2
     11 {
     12     public static void main(String[] args)
     13     {
     14         treeSerDemo2();
     15     }
     16     
     17     public static void treeSerDemo2()
     18     {
     19         TreeSet ts = new TreeSet(new MyComparator());
     20         ts.add(new Student2("t1",11));
     21         // 如果Student类没有实现Comparator接口，多添加下面一条数据就抛异常
     22         // 因为这个类中的数据没有可比较性
     23         ts.add(new Student2("t2",12));
     24         ts.add(new Student2("t3",13));
     25         
     26         Iterator it = ts.iterator();
     27         while(it.hasNext())
     28         {
     29             Student2 stu = (Student2)it.next();
     30             System.out.println("name:" + stu.getName() + ",age:" + stu.getAge());
     31         }
     32     }
     33 }
     34 
     35 class MyComparator implements Comparator
     36 {
     37 
     38     @Override
     39     public int compare(Object o1, Object o2)
     40     {
     41        if(!(o1 instanceof Student2) || !(o2 instanceof Student2))
     42         {
     43             try
     44             {
     45                 throw new Exception("传入的比较对象不是要求的比较对象");
     46             } catch (Exception e)
     47             {
     48                 e.printStackTrace();
     49             }
     50 }
     51 
     52         Student2 stu1 = (Student2)o1;
     53         Student2 stu2 = (Student2)o2;
     54         
     55         int num = stu1.getName().compareTo(stu2.getName());
     56         if(num == 0)
     57         {
     58             // int型比较方法一
     59             // 封装成Interger对象进行比较
     60             // return new Integer(stu1.getAge()).compareTo(new Integer(stu2.getAge()));
     61             
     62             // int型比较方法二
     63             if(stu1.getAge() > stu2.getAge())
     64                 return 1;
     65             if(stu1.getAge() == stu2.getAge())
     66                 return 0;
     67             return -1;
     68         }
     69         
     70         return num;
     71     }
     72     
     73 }
     74 
     75 class Student2
     76 {
     77     private String name;
     78     private int age;
     79     
     80     public Student2(String name, int age)
     81     {
     82         this.name = name;
     83         this.age = age;
     84     }
     85     
     86     public String getName()
     87     {
     88         return name;
     89     }
     90     public void setName(String name)
     91     {
     92         this.name = name;
     93     }
     94     public int getAge()
     95     {
     96         return age;
     97     }
     98     public void setAge(int age)
     99     {
    100         this.age = age;
    101     }
    102 }
    复制代码
     
    
    复制代码
     1 /**
     2  * 功能：比较字符串长度是否相等
     3  */
     4 package collection;
     5 
     6 import java.util.Comparator;
     7 import java.util.Iterator;
     8 import java.util.TreeSet;
     9 
    10 public class TreeSetDemo3
    11 {
    12     public static void main(String[] args)
    13     {
    14         TreeSet ts = new TreeSet(new MyStrComparator());
    15         ts.add("asd");
    16         ts.add("wer");
    17          ts.add("qaz");
    18         ts.add("qwerty");
    19         ts.add("df");
    20         
    21         Iterator it = ts.iterator();
    22         while(it.hasNext())
    23         {
    24             System.out.println(it.next());
    25         }
    26     }
    27 }
    28 
    29 class MyStrComparator implements Comparator
    30 {
    31     @Override
    32     public int compare(Object o1, Object o2)
    33     {
    34         String s1 = (String)o1;
    35         String s2 = (String)o2;
    36         
    37         int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
    38         if(num == 0)
    39         {
    40             return s1.compareTo(s2);
    41         }
    42         return num;
    43     }
    44     
    45 }
    复制代码
     
    
    复制代码
     1 /**
     2  * 功能：匿名内部类的使用
     3  */
     4 package collection;
     5 
     6 import java.util.Comparator;
     7 import java.util.Iterator;
     8 import java.util.TreeSet;
     9 
    10 public class TreeSetDemo4
    11 {
    12     public static void main(String[] args)
    13     {
    14         TreeSet ts = new TreeSet(new Comparator(){
    15             @Override
    16             public int compare(Object o1, Object o2)
    17             {
    18                 String s1 = (String)o1;
    19                 String s2 = (String)o2;
    20                 
    21                 int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
    22                 if(num == 0)
    23                 {
    24                     return s1.compareTo(s2);
    25                 }
    26                 return num;
    27             }});
    28         
    29         ts.add("asd");
    30         ts.add("wer");
    31         ts.add("qwerty");
    32         ts.add("df");
    33         
    34         Iterator it = ts.iterator();
    35         while(it.hasNext())
    36         {
    37             System.out.println(it.next());
    38         }
    39     }
    40 }
    复制代码
     
    
    复制代码
     1 /**
     2  * 功能：泛型的使用
     3  */
     4 package collection;
     5 
     6 import java.util.ArrayList;
     7 import java.util.Iterator;
     8 
     9 public class GenericDemo
    10 {
    11     public static void main(String[] args)
    12     {
    13         genericDemo2();
    14     }
    15     
    16     // 没有使用泛型
    17     public static void genericDemo()
    18     {
    19         ArrayList al = new ArrayList();
    20         al.add("qwe");
    21         // 上面添加的字符串，下面添加的是int，迭代时肯定会报类型转换异常
    22         al.add(4);
    23         
    24         Iterator it = al.iterator();
    25         while(it.hasNext())
    26         {
    27             // 需要类型转换
    28             // 此处在运行时会报类型转换异常
    29             // 在编译时不会报异常
    30             String s = (String)it.next();
    31             System.out.println(s + ":" + s.length());
    32         }
    33     }
    34     
    35     // JDK1.5之后使用泛型
    36     // 解决安全问题
    37     public static void genericDemo2()
    38     {
    39         // 指定只添加String类型数据
    40         ArrayList<String> al = new ArrayList<String>();
    41         al.add("qwe");
    42         // 编译时下面这条语句就报错了
    43         // al.add(4);
    44         
    45         // 迭代器也通过泛型指定类型
    46         // 后续就不需要进行内外部转换了
    47         Iterator<String> it = al.iterator();
    48         while(it.hasNext())
    49         {
    50             String s = it.next();
    51             System.out.println(s + ":" + s.length());
    52         }
    53     }
    54 }
    
     1 /**
     2  * 功能：定义泛型类
     3  */
     4 package collection;
     5 
     6 public class GenericClass
     7 {
     8     public static void main(String[] args)
     9     {
    10         Tool tool = new Tool();
    11         tool.setObject(new Teacher());
    12         // 没用泛型之前，需要进行强转
    13         Teacher teacher = (Teacher) tool.getObject();
    14         System.out.println(teacher);
    15         
    16         Util<Doctor> util = new Util<Doctor>();
    17         util.setObject(new Doctor());
    18         // 使用泛型之后，不需要进行强转
    19         Doctor doctor = util.getObject();
    20         System.out.println(doctor);
    21     }
    22 }
    23 
    24 // 没用泛型之前
    25 class Tool
    26 {
    27     private Object object;
    28 
    29     public Object getObject()
    30     {
    31         return object;
    32     }
    33 
    34     public void setObject(Object object)
    35     {
    36         this.object = object;
    37     }
    38     
    39 }
    40 
    41 // 用了泛型之后
    42 class Util<Q>
    43 {
    44     private Q object;
    45     
    46     public void setObject(Q q)
    47     {
    48         this.object = q;
    49     }
    50     public Q getObject()
    51     {
    52         return object;
    53     }
    54     
    55 }
    56 
    57 class Teacher
    58 {
    59     
    60 }
    61 
    62 class Doctor
    63 {
    64     
    65 }
    
    
     1 /**
     2  * 功能：将泛型定义在方法上
     3  */
     4 package collection;
     5 
     6 public class GenericDemo2
     7 {
     8     public static void main(String[] args)
     9     {
    10         Utils ut = new Utils();
    11         // 可以打印字符串
    12         ut.show("qwe");
    13         // 可以打印int类型
    14         ut.show(12);
    15     }
    16 }
    17 
    18 class Utils
    19 {
    20     public <T> void show(T t)
    21     {
    22         System.out.println("show:" + t);
    23     }
    24     
    25     public <Q> void print(Q q)
    26     {
    27         System.out.println("print:" + q);
    28     }
    29 }
    
     1 /**
     2  * 功能：类和方法上都定义泛型
     3  */
     4 package collection;
     5 
     6 public class GenericDemo3
     7 {
     8     public static void main(String[] args)
     9     {
    10         Tools<String> tl = new Tools<String>();
    11         // 只能打印String类型
    12         tl.show("qwer");
    13         // 打印其他类型报错
    14         // tl.show(123);
    15         
    16         // 可以打印String类型
    17         tl.print("qwe");
    18         // 也可以打印其他类型
    19         tl.print(123);
    20         
    21         Tools.display("qwe");
    22         Tools.display(123);
    23     }
    24 }
    25 
    26 class Tools<T>
    27 {
    28     // 这个方法的类型是跟着对象（类型T）走的
    29     public void show(T t)
    30     {
    31         System.out.println("show:" + t);
    32     }
    33     
    34     // 这个方法的类型是跟着Q走的
    35     public <Q> void print(Q q)
    36     {
    37         System.out.println("print:" + q);
    38     }
    39     
    40     // 泛型定义在返回值的前面，修饰符的后面
    41     public static <W> void display(W w)
    42     {
    43         System.out.println("display:" + w);
    44     }
    45 }
    
    
     1 /**
     2  * 功能：接口上定义泛型
     3  */
     4 package collection;
     5 
     6 public class GenericDemo4
     7 {
     8     public static void main(String[] args)
     9     {
    10         InterImpl ii = new InterImpl();
    11         ii.show("qwe");
    12         
    13         InterImpl2<String> ii2 = new InterImpl2<String>();
    14         ii2.show("asd");
    15         
    16         InterImpl2<Integer> ii3 = new InterImpl2<Integer>();
    17         ii3.show(123);
    18     }
    19 }
    20 
    21 interface Inter<T>
    22 {
    23     public void show(T t);
    24 }
    25 
    26 class InterImpl implements Inter<String>
    27 {
    28     @Override
    29     public void show(String t)
    30     {
    31         System.out.println("show:" + t);
    32     }
    33 }
    34 
    35 class InterImpl2<T> implements Inter<T>
    36 {
    37     @Override
    38     public void show(T t)
    39     {
    40         System.out.println("show:" + t);
    41     }
    42 }
    复制代码
     
    
    复制代码
    
         1 /**
         2  * 功能：泛型的高级特性
         3  */
         4 package collection;
         5 
         6 import java.util.ArrayList;
         7 import java.util.Iterator;
         8 
         9 public class GenericDemo5
        10 {
        11     public static void main(String[] args)
        12     {
        13         ArrayList<String> al1 = new ArrayList<String>();
        14         al1.add("qwe");
        15         al1.add("asd");
        16         al1.add("zxc");
        17         
        18         ArrayList<Integer> al2 = new ArrayList<Integer>();
        19         al2.add(123);
        20         al2.add(456);
        21         al2.add(789);
        22         
        23         demo(al1);
        24         demo(al2);
        25         
        26         demo2(al1);
        27         demo2(al2);
        28     }
        29     
        30     // 不清楚是什么类型时候，可以用？代替
        31     public static void demo(ArrayList<?> al)
        32     {
        33         Iterator<?> it = al.iterator();
        34         while(it.hasNext())
        35         {
        36             System.out.println("al:" + it.next());
        37             // 以下使用length()是错误的
        38             // 因为不知道是什么类型，所以不能使用某一具体类型的特有方法
        39             // System.out.println(it.next().length());
        40         }
        41     }
        42     
        43     // 也可以换成T，但T代表了某一个具体类型
        44     // 操作方面有一点变化
        45     public static <T> void demo2(ArrayList<T> al)
        46     {
        47         Iterator<T> it = al.iterator();
        48         while(it.hasNext())
        49         {
        50             System.out.println("al:" + it.next());
        51             // 使用了某一具体类型之后
        52             // 可以用这个具体类型来接收迭代出来的元素，并进行其他具体操作
        53             // T t = it.next();
        54             // System.out.println("al:" + t);
        55         }
        56     }
        57 }
    
    
          1 /**
          2  * 功能：泛型的高级特性2
          3  */
          4 package collection;
          5 
          6 import java.util.ArrayList;
          7 import java.util.Iterator;
          8 
          9 public class GenericDemo6
         10 {
         11     public static void main(String[] args)
         12     {
         13         ArrayList<Person> al = new ArrayList<Person>();
         14         al.add(new Person("qwe"));
         15         al.add(new Person("asd"));
         16         al.add(new Person("zxc"));
         17         
         18         ArrayList<Worker> al2 = new ArrayList<Worker>();
         19         al2.add(new Worker("qwe"));
         20         al2.add(new Worker("asd"));
         21         al2.add(new Worker("zxc"));
         22         
         23         ArrayList<Student6> al3 = new ArrayList<Student6>();
         24         al3.add(new Student6("qwe"));
         25         al3.add(new Student6("asd"));
         26         al3.add(new Student6("zxc"));
         27         
         28         // 正确
         29         demo(al);
         30         // 错误，以下两种情况都是不允许的，左右不匹配
         31         // ArrayList<Person> al2 = new ArrayList<Student>();
         32         // ArrayList<Student> al2 = new ArrayList<Person>();
         33         // demo(al2);
         34         
         35         demo3(al2);
         36         demo3(al);
         37         // Student6类不是Person类的子类，所以下面写法错误
         38         // demo3(al3);
         39         
         40         demo4(al);
         41         demo4(al2);
         42         // Student6类不是Worker类的父类，所以下面写法错误
         43         // demo4(al3);
         44     }
         45     
         46     public static void demo(ArrayList<Person> al)
         47     {
         48         Iterator<Person> it = al.iterator();
         49         while(it.hasNext())
         50         {
         51             Person p = it.next();
         52             System.out.println("name:" + p.getName());
         53         }
         54     }
         55     
         56     // 打印出所有类型
         57     public static void demo2(ArrayList<?> al)
         58     {
         59         Iterator<?> it = al.iterator();
         60         while(it.hasNext())
         61         {
         62             System.out.println(it.next());
         63         }
         64     }
         65     
         66     // 打印出指定的范围：泛型限定
         67     // 只打印Person和它的子类
         68     public static void demo3(ArrayList<? extends Person> al)
         69     {
         70         Iterator<? extends Person> it = al.iterator();
         71         while(it.hasNext())
         72         {
         73             System.out.println(it.next().getName());
         74         }
         75     }
         76     
         77     public static void demo4(ArrayList<? super Worker> al)
         78     {
         79         Iterator<? super Worker> it = al.iterator();
         80         while(it.hasNext())
         81         {
         82             System.out.println(it.next());
         83         }
         84     }
         85 }
         86 
         87 class Person
         88 {
         89     private String name;
         90     
         91     public Person(String name)
         92     {
         93         this.name = name;
         94     }
         95     
         96     public String getName()
         97     {
         98         return name;
         99     }
        100     
        101     public void setName(String name)
        102     {
        103         this.name = name;
        104     }
        105 }
        106 
        107 class Worker extends Person
        108 {
        109     public Worker(String name)
        110     {
        111         super(name);
        112     }
        113 }
        114 
        115 class Student6
        116 {
        117     private String name;
        118     public Student6(String name)
        119     {
        120         this.name = name;
        121     }
        122     public String getName()
        123     {
        124         return name;
        125     }
        126     public void setName(String name)
        127     {
        128         this.name = name;
        129     }
        130 }
    
      1 /**
      2  * 功能：泛型的高级应用3
      3  */
      4 package collection;
      5 
      6 import java.util.Comparator;
      7 import java.util.Iterator;
      8 import java.util.TreeSet;
      9 
     10 public class GenericDemo7
     11 {
     12     public static void main(String[] args)
     13     {
     14         // 使用Studnet3类的构造器
     15         // TreeSet<Student3> tr = new TreeSet<Student3>(new StuComparator());
     16         // 使用通用的比较器（父类的比较器）
     17         TreeSet<Student3> tr = new TreeSet<Student3>(new MyComparator2());
     18         tr.add(new Student3("stu4"));
     19         tr.add(new Student3("stu2"));
     20         tr.add(new Student3("stu3"));
     21         
     22         Iterator<Student3> it = tr.iterator();
     23         while(it.hasNext())
     24         {
     25             System.out.println("tr:" + it.next().getName());
     26         }
     27         
     28         // 使用Worker2类的构造器
     29         // TreeSet<Worker2> tr2 = new TreeSet<Worker2>(new WorComparator());
     30         // 使用通用的比较器（父类的比较器）
     31         TreeSet<Worker2> tr2 = new TreeSet<Worker2>(new MyComparator2());
     32         tr2.add(new Worker2("wor1"));
     33         tr2.add(new Worker2("wor5"));
     34         tr2.add(new Worker2("wor3"));
     35         
     36         Iterator<Worker2> it2 = tr2.iterator();
     37         while(it2.hasNext())
     38         {
     39             System.out.println("tr:" + it2.next().getName());
     40         }
     41     }
     42 }
     43 
     44 // Student3类的比较器，分开写很麻烦
     45 class StuComparator implements Comparator<Student3>
     46 {
     47     @Override
     48     public int compare(Student3 o1, Student3 o2)
     49     {
     50         return o1.getName().compareTo(o2.getName());
     51     }
     52 }
     53 
     54 // Worker2类的比较器，分开写很麻烦
     55 class WorComparator implements Comparator<Worker2>
     56 {
     57     @Override
     58     public int compare(Worker2 o1, Worker2 o2)
     59     {
     60         return o1.getName().compareTo(o2.getName());
     61     }
     62 }
     63 
     64 // Comparator<? super E>
     65 class MyComparator2 implements Comparator<Person2>
     66 {
     67     @Override
     68     public int compare(Person2 o1, Person2 o2)
     69     {
     70         return o1.getName().compareTo(o2.getName());
     71     }
     72 }
     73 
     74 class Person2
     75 {
     76     private String name;
     77     
     78     public Person2(String name)
     79     {
     80         this.name = name;
     81     }
     82 
     83     public String getName()
     84     {
     85         return name;
     86     }
     87 
     88     public void setName(String name)
     89     {
     90         this.name = name;
     91     }
     92     
     93 }
     94 
     95 class Student3 extends Person2
     96 {
     97     // private String name;
     98     public Student3(String name)
     99     {
    100         super(name);
    101     }
    102 }
    103 
    104 class Worker2 extends Person2
    105 {
    106     public Worker2(String name)
    107     {
    108         super(name);
    109     }
    110 }
    
    
     1 /**
     2  * 功能：获取Map集合数据的两种方式
     3  */
     4 package collection;
     5 
     6 import java.util.HashMap;
     7 import java.util.Iterator;
     8 import java.util.Map;
     9 import java.util.Set;
    10 
    11 public class MapDemo
    12 {
    13     public static void main(String[] args)
    14     {
    15         keySet();
    16         entrySet();
    17     }
    18     
    19     // 方法一：通过keySet()来获取
    20     public static void keySet()
    21     {
    22         HashMap<String,String> map = new HashMap<String,String>();
    23         map.put("01", "zhangsan");
    24         map.put("05", "lisi");
    25         map.put("03", "wangwu");
    26         
    27         Set<String> keySet = map.keySet();
    28         
    29         Iterator<String> it = keySet.iterator();
    30         while(it.hasNext())
    31         {
    32             String key = it.next();
    33             String value = map.get(key);
    34             System.out.println("key:" + key + ",value:" + value);
    35         }
    36     }
    37     
    38     // 方法二：通过entrySet()来获取
    39     public static void entrySet()
    40     {
    41         HashMap<String,String> map = new HashMap<String,String>();
    42         map.put("01", "zhangsan");
    43         map.put("05", "lisi");
    44         map.put("03", "wangwu");
    45         
    46         Set<Map.Entry<String, String>> entrySet = map.entrySet();
    47         Iterator<Map.Entry<String, String>> it = entrySet.iterator();
    48         while(it.hasNext())
    49         {
    50             Map.Entry<String, String> me = it.next();
    51             String key = me.getKey();
    52             String value = me.getValue();
    53             System.out.println("key:" + key + ",value:" + value);
    54         }
    55     }
    56 }
    
    
     1 /**
     2  * 功能：HashMap集合的扩展
     3  */
     4 package collection;
     5 
     6 import java.util.HashMap;
     7 import java.util.Iterator;
     8 import java.util.Set;
     9 
    10 public class MapDemo2
    11 {
    12     public static void main(String[] args)
    13     {
    14         HashMap<String,String> yure = new HashMap<String,String>();
    15         yure.put("01", "zhangsan");
    16         yure.put("02", "lisi");
    17         
    18         HashMap<String,String> jiuye = new HashMap<String,String>();
    19         jiuye.put("03", "wangwu");
    20         jiuye.put("04", "zhaoliu");
    21         
    22         HashMap<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();
    23         czbk.put("yure", yure);
    24         czbk.put("jiuye", jiuye);
    25         
    26         Set<String> map = czbk.keySet();
    27         Iterator<String> it = map.iterator();
    28         while(it.hasNext())
    29         {
    30             String key = it.next();
    31             HashMap<String,String> values = czbk.get(key);
    32             System.out.println("key:" + key + "values:" + values);
    33             getStuInfo(values);
    34         }
    35         
    36         // getStuInfo(jiuye);
    37     }
    38     
    39     public static void getStuInfo(HashMap<String,String> room)
    40     {
    41         Set<String> map = room.keySet();
    42         Iterator<String> it = map.iterator();
    43         while(it.hasNext())
    44         {
    45             String key = it.next();
    46             String value = room.get(key);
    47             System.out.println("id:" + key + ",value:" + value);
    48         }
    49     }
    50 }
    
    
    
     1 /**
     2  * 功能：JDK1.5新特性，可变参数
     3  */
     4 package collection;
     5 
     6 public class CollectionDemo
     7 {
     8     public static void main(String[] args)
     9     {
    10         syso(1,2,3,4,5);
    11         syso(3,4);
    12     }
    13     
    14     public static void syso(int... arr)
    15     {
    16         for(int i=0;i<arr.length;i++)
    17         {
    18             System.out.println(i);
    19         }
    20     }
    21 }
    
    
     1 /**
     2  * 功能：JDK1.5新特性，静态导入
     3  */
     4 package collection;
     5 
     6 import java.util.Arrays;
     7 
     8 // 实现静态导入，导入的是Arrays这个类中的所有静态成员
     9 import static java.util.Arrays.*;
    10 
    11 public class CollectionDemo2
    12 {
    13     public static void main(String[] args)
    14     {
    15         int[] arr = {6,2,8};
    16         // 原来是这样写的
    17         // int index = Arrays.binarySearch(arr, 2);
    18         // 现在可以这样写
    19         int index = binarySearch(arr, 2);
    20         
    21         System.out.println(index);
    22         
    23     }
    24 }

[https_www.cnblogs.com_kehuaihan_p_6759988.html]: https://www.cnblogs.com/kehuaihan/p/6759988.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwMjQyOTg3_size_16_color_FFFFFF_t_70]: /images/20220329/ced04ec0efea4f9290a041a7ef88fbf9.png