推荐收藏：一篇文章带你帮你整合Java集合的所有知识点

淩亂°似流年 2022-12-24 14:50 120阅读 0赞

### 文章目录 ###

*  一、数组和集合的区别
 *  二、集合类体系结构
 *  三、Collection集合
 *   *  1.Collection集合概述
     *  2.创建Collection集合的对象
     *  3.Collection集合常用方法
     *  4.Collection的代码实例
     *  5.Collection集合的遍历
     *   *  （一） 迭代器
         *   *  （1）Iterator中的常用方法
             *  （2）Iterator的代码实现
         *  （二）增强for循环
         *   *  （1）增强for循环的介绍
             *  （2）增强for循环的格式
             *  （3）增强for循环的代码实例
     *  6.List集合
     *   *  （一）List集合的概述
         *  （二）List集合的特点
         *  （三）List集合的特有方法
         *  （四）ArrayList集合
         *  （五）LinkedList集合
         *   *  （1）LinkedList集合的特点
             *  （2）LinkedList集合的特有方法
             *  （3）LinkedList集合的代码实例
     *  7.Set集合
     *   *  （一）Set集合的特点
         *  （二）TreeSet集合
         *   *  （1）TreeSet集合的特点
             *   *  （2）自然排序Comparable的使用
                 *  （3）比较器排序Comparator的使用
                 *  （4）两种比较方式总结
         *  （三）HashSet集合
         *   *  （1）HashSet集合的特点
             *  （2）HashSet集合的代码实例
             *  （3）HashSet集合的注意事项
 *  四、Map集合
 *   *  1.Map集合概述
     *  2.Map集合的特点
     *  3.Map集合的常用方法
     *  4.Map集合的获取方法
     *  5.Map集合的遍历
     *   *  （一）方式1
         *  （二）方式2
     *  6.HashMap集合
     *   *  （一）HashMap集合的特点
         *  （二）HashMap集合的代码实例
     *  7.HashMap集合
     *   *  （一）TreeMap集合的特点
         *  （二）TreeMap集合的代码实例

--------------------

# 一、数组和集合的区别 #

相同点：

*  都是容器，可以存储多个数据

不同点：

*  数组的长度是不可变的，集合的长度是可变的
 *  数组可以存基本数据类型和引用数据类型  
    集合只能存引用数据类型，如果要存基本数据类型，需要存对应的包装类

# 二、集合类体系结构 #

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

# 三、Collection集合 #

## 1.Collection集合概述 ##

*  是单列集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
 *  JDK不提供此接口的任何直接实现，它提供更具体的子接口实现

## 2.创建Collection集合的对象 ##

*  多态的方式
 *  具体的实现类ArrayList

## 3.Collection集合常用方法 ##

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean add(E e)</td> 
   <td>添加元素</td> 
  </tr> 
  <tr> 
   <td>boolean remove(Object o)</td> 
   <td>从集合中移除指定的元素</td> 
  </tr> 
  <tr> 
   <td>boolean removeIf(Object o)</td> 
   <td>根据条件进行移除</td> 
  </tr> 
  <tr> 
   <td>void clear()</td> 
   <td>清空集合中的元素</td> 
  </tr> 
  <tr> 
   <td>boolean contains(Object o)</td> 
   <td>判断集合中是否存在指定的元素</td> 
  </tr> 
  <tr> 
   <td>boolean isEmpty()</td> 
   <td>判断集合是否为空</td> 
  </tr> 
  <tr> 
   <td>int size()</td> 
   <td>集合的长度，也就是集合中元素的个数</td> 
  </tr> 
 </tbody> 
</table>

## 4.Collection的代码实例 ##

Collection<String> s = new ArrayList<>();
    s.add("a");
    s.add("a");
    s.add("a");
    System.out.println(s);
    
    s.remove("a");
    System.out.println(s);
    s.removeIf(
            (String s1) -> {
        
                return s1.length() == 1;
            }
    );
    System.out.println(s);
    s.add("b");
    s.add("b");
    s.add("c");
    s.clear();
    System.out.println(s);
    System.out.println(s.contains("a"));
    System.out.println(s.isEmpty());
    System.out.println(s.size());

> \[a, a, a\]  
> \[a, a\]  
> \[\]  
> \[\]  
> false  
> true  
> 0

## 5.Collection集合的遍历 ##

### （一） 迭代器 ###

*  迭代器，集合专用遍历方式
 *  Iterator iterator()：返回集合中元素的迭代器，通过集合对象的iterator()方法得到

#### （1）Iterator中的常用方法 ####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean hasNext()</td> 
   <td>判断当前位置是否有元素可以被取出</td> 
  </tr> 
  <tr> 
   <td>E next()</td> 
   <td>获取当前位置的元素,将迭代器对象移向下一个索引位置</td> 
  </tr> 
  <tr> 
   <td>void remove()</td> 
   <td>删除迭代器对象当前指向的元素</td> 
  </tr> 
 </tbody> 
</table>

#### （2）Iterator的代码实现 ####

Collection<String> al = new ArrayList<>();
    al.add("aab");
    al.add("aab");
    al.add("aab");
    Iterator<String> iterator = al.iterator();
    while (iterator.hasNext()) {
        
    	System.out.println(iterator.next());
    }

> aab  
> aab  
> aab

### （二）增强for循环 ###

#### （1）增强for循环的介绍 ####

*  它是JDK5之后出现的,其内部原理是一个Iterator迭代器
 *  实现Iterable接口的类才可以使用迭代器和增强for
 *  简化数组和Collection集合的遍历

#### （2）增强for循环的格式 ####

for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {
        
    	// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可
    }

#### （3）增强for循环的代码实例 ####

Collection<String> al = new ArrayList<>();
    al.add("aab");
    al.add("aab");
    al.add("aab");
    al.add("aab");
    for (String s : al) {
        
        System.out.println(s);
    }

> aab  
> aab  
> aab  
> aab

## 6.List集合 ##

### （一）List集合的概述 ###

*  有序集合，这里的有序指的是存取顺序
 *  用户可以精确控制列表中每个元素的插入位置，用户可以通过整数索引访问元素，并搜索列表中的元素
 *  与Set集合不同，列表通常允许重复的元素

### （二）List集合的特点 ###

*  存取有序
 *  可以重复
 *  有索引

### （三）List集合的特有方法 ###

*  方法介绍

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void add(int index,E element)</td> 
   <td>在此集合中的指定位置插入指定的元素</td> 
  </tr> 
  <tr> 
   <td>E remove(int index)</td> 
   <td>删除指定索引处的元素，返回被删除的元素</td> 
  </tr> 
  <tr> 
   <td>E set(int index,E element)</td> 
   <td>修改指定索引处的元素，返回被修改的元素</td> 
  </tr> 
  <tr> 
   <td>E get(int index)</td> 
   <td>返回指定索引处的元素</td> 
  </tr> 
 </tbody> 
</table>

### （四）ArrayList集合 ###

底层是数组结构实现，查询快、增删慢  
详情见[ArrayList集合2020年][ArrayList_2020]  
本文不做详细解释

### （五）LinkedList集合 ###

#### （1）LinkedList集合的特点 ####

底层是双向链表结构，查询慢、增删快

#### （2）LinkedList集合的特有方法 ####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public void addFirst(E e)</td> 
   <td>在该列表开头插入指定的元素</td> 
  </tr> 
  <tr> 
   <td>public void addLast(E e)</td> 
   <td>将指定的元素追加到此列表的末尾</td> 
  </tr> 
  <tr> 
   <td>public E getFirst()</td> 
   <td>返回此列表中的第一个元素</td> 
  </tr> 
  <tr> 
   <td>public E getLast()</td> 
   <td>返回此列表中的最后一个元素</td> 
  </tr> 
  <tr> 
   <td>public E removeFirst()</td> 
   <td>从此列表中删除并返回第一个元素</td> 
  </tr> 
  <tr> 
   <td>public E removeLast()</td> 
   <td>从此列表中删除并返回最后一个元素</td> 
  </tr> 
 </tbody> 
</table>

#### （3）LinkedList集合的代码实例 ####

LinkedList<String> list = new LinkedList<>();
    list.add("aaa");
    list.add("aaa");
    list.add("aaa");
    list.add("aaa");
    list.add(3,"aa");
    System.out.println(list);
    System.out.println("__");
    list.addFirst("aa");
    list.addLast("eee");
    list.addFirst("aaa");
    for (String s : list) {
        
        System.out.print(s + " ");
    }
    System.out.println();
    System.out.println("__");
    System.out.println(list.getLast());
    String first = list.getFirst();
    System.out.println(first);
    String s = list.removeLast();
    System.out.println(s);
    System.out.println("__");
    for (int i = 0; i < list.size(); i++) {
        
        System.out.print(list.get(i) + " ");
    }

> \[aaa, aaa, aaa, aa, aaa\]  
> \_\_  
> aaa aa aaa aaa aaa aa aaa eee  
> \_\_  
> eee  
> aaa  
> eee  
> \_\_  
> aaa aa aaa aaa aaa aa aaa

## 7.Set集合 ##

### （一）Set集合的特点 ###

*  不可以存储重复元素
 *  没有索引，不能使用普通for循环遍历

### （二）TreeSet集合 ###

#### （1）TreeSet集合的特点 ####

*  不可以存储重复元素
 *  没有索引
 *  可以将元素按照规则进行排序  
    TreeSet()：根据其元素的自然排序进行排序  
    TreeSet(Comparator comparator) ：根据指定的比较器进行排序

##### （2）自然排序Comparable的使用 #####

*  案例需求  
    有一个学生类， 有这些属性， 数学成绩 math ， 英语成绩 English ， 语文 Chinese。有5个学生， 按照学生的总成绩 从大到小排序。如果总成绩相同， 请按照数学排；如果总成绩同了 数学也同了，语文排；语文也同了，按英语排；英语也同了，按姓名排；姓名也同了，就是同一个人，去除掉。
 *  实现步骤
    
    1.  使用空参构造创建TreeSet集合  
        用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
    2.  自定义的Student类实现Comparable接口  
        自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
    3.  重写接口中的compareTo方法  
        重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

import java.util.TreeSet;
    
    public class Demo4 {
        
        public static void main(String[] args) {
        
            TreeSet<Student> sts = new TreeSet<>();
            sts.add(new Student(30, 50, 30, "zhangsan"));
            sts.add(new Student(30, 50, 30, "zhangsan"));
            sts.add(new Student(50, 50, 50, "zhangsi"));
            sts.add(new Student(100, 10, 0, "zhangwu"));
            sts.add(new Student(70, 50, 30, "zhangliu"));
            sts.add(new Student(30, 50, 30, "ahangsan"));
            for (Student st : sts) {
        
                System.out.println(st);
            }
        }
    }
    class Student implements Comparable<Student> {
        
        private int math;
        private int English;
        private int Chinese;
        private String name;
    
        @Override
        public int compareTo(Student o) {
        
            if ((this.math + this.English + this.Chinese) != (o.math + o.English + o.Chinese)) {
        
                return (o.math + o.English + o.Chinese) - (this.math + this.English + this.Chinese);
            }
            if (this.math != o.math) {
        
                return o.math - this.math;
            }
            if (this.Chinese != o.Chinese) {
        
                return o.Chinese - this.Chinese;
            }
            if (this.English != o.English) {
        
                return o.English - this.English;
            }
            return this.name.compareTo(o.name);
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "math=" + math +
                    ", English=" + English +
                    ", Chinese=" + Chinese +
                    ", name=" + name +
                    '}';
        }
    
        public Student() {
        
        }
    
        public Student(int math, int english, int chinese, String name) {
        
            this.math = math;
            English = english;
            Chinese = chinese;
            this.name = name;
        }
    
        public int getMath() {
        
            return math;
        }
    
        public void setMath(int math) {
        
            this.math = math;
        }
    
        public int getEnglish() {
        
            return English;
        }
    
        public void setEnglish(int english) {
        
            English = english;
        }
    
        public int getChinese() {
        
            return Chinese;
        }
    
        public void setChinese(int chinese) {
        
            Chinese = chinese;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    }

> Student\{math=70, English=50, Chinese=30, name=zhangliu\}  
> Student\{math=50, English=50, Chinese=50, name=zhangsi\}  
> Student\{math=100, English=10, Chinese=0, name=zhangwu\}  
> Student\{math=30, English=50, Chinese=30, name=ahangsan\}  
> Student\{math=30, English=50, Chinese=30, name=zhangsan\}

##### （3）比较器排序Comparator的使用 #####

*  案例需求  
    有一个学生类， 有这些属性， 数学成绩 math ， 英语成绩 English ， 语文 Chinese。有5个学生， 按照学生的总成绩 从大到小排序。如果总成绩相同， 请按照数学排；如果总成绩同了 数学也同了，语文排；语文也同了，按英语排；英语也同了，按姓名排；姓名也同了，就是同一个人，去除掉。
 *  实现步骤
    
    1.  用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
    2.  比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
    3.  重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

import java.util.Comparator;
    import java.util.TreeSet;
    
    public class Demo4 {
        
        public static void main(String[] args) {
        
            TreeSet<Student> sts = new TreeSet<>(
                    new Comparator<Student>() {
        
                        @Override
                        public int compare(Student o1, Student o2) {
        
                            if ((o1.getMath() + o1.getEnglish() + o1.getChinese()) != (o2.getMath() + o2.getEnglish() + o2.getChinese())) {
        
                                return (o2.getMath() + o2.getEnglish() + o2.getChinese()) - (o1.getMath() + o1.getEnglish() + o1.getChinese());
                            }
                            if (o1.getMath() != o2.getMath()) {
        
                                return o2.getMath() - o1.getMath();
                            }
                            if (o1.getChinese() != o2.getChinese()) {
        
                                return o2.getChinese() - o1.getChinese();
                            }
                            if (o1.getEnglish() != o2.getEnglish()) {
        
                                return o2.getEnglish() - o1.getEnglish();
                            }
                            return o1.getName().compareTo(o2.getName());
                        }
                    }
            );
            sts.add(new Student(30, 50, 30, "zhangsan"));
            sts.add(new Student(30, 50, 30, "zhangsan"));
            sts.add(new Student(50, 50, 50, "zhangsi"));
            sts.add(new Student(100, 10, 0, "zhangwu"));
            sts.add(new Student(70, 50, 30, "zhangliu"));
            sts.add(new Student(30, 50, 30, "ahangsan"));
            for (Student st : sts) {
        
                System.out.println(st);
            }
        }
    }
    class Student {
        
        private int math;
        private int English;
        private int Chinese;
        private String name;
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "math=" + math +
                    ", English=" + English +
                    ", Chinese=" + Chinese +
                    ", name=" + name +
                    '}';
        }
    
        public Student() {
        
        }
    
        public Student(int math, int english, int chinese, String name) {
        
            this.math = math;
            English = english;
            Chinese = chinese;
            this.name = name;
        }
    
        public int getMath() {
        
            return math;
        }
    
        public void setMath(int math) {
        
            this.math = math;
        }
    
        public int getEnglish() {
        
            return English;
        }
    
        public void setEnglish(int english) {
        
            English = english;
        }
    
        public int getChinese() {
        
            return Chinese;
        }
    
        public void setChinese(int chinese) {
        
            Chinese = chinese;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    }

##### （4）两种比较方式总结 #####

两种比较方式小结

*  自然排序: 自定义类实现Comparable接口,重写compareTo方法,根据返回值进行排序
 *  比较器排序: 创建TreeSet对象的时候传递Comparator的实现类对象,重写compare方法,根据返回值进行排序
 *  在使用的时候,默认使用自然排序,当自然排序不满足现在的需求时,必须使用比较器排序

两种方式中关于返回值的规则

*  如果返回值为负数，表示当前存入的元素是较小值，存左边
 *  如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
 *  如果返回值为正数，表示当前存入的元素是较大值，存右边

### （三）HashSet集合 ###

#### （1）HashSet集合的特点 ####

*  底层数据结构是哈希表（JDK1.8以前：数组+链表 JDK1.8以后：数组+链表/红黑树）
 *  存取无序
 *  不可以存储重复元素
 *  没有索引，不能使用普通for循环遍历

#### （2）HashSet集合的代码实例 ####

import java.util.HashSet;
    import java.util.Objects;
    
    public class Demo1 {
        
        public static void main(String[] args) {
        
            HashSet<Student> hs = new HashSet<>();
            Student s1 = new Student("小黑", 34);
            Student s2 = new Student("小黑", 34);
            Student s3 = new Student("小红", 36);
            Student s4 = new Student("小蓝", 33);
            hs.add(s1);
            hs.add(s2);
            hs.add(s3);
            hs.add(s4);
            for (Student h : hs) {
        
                System.out.println(h);
            }
        }
    }
    class Student{
        
        private String name;
        private int age;
    
        @Override
        public boolean equals(Object o) {
        
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return age == student.age &&
                    Objects.equals(name, student.name);
        }
    
        @Override
        public int hashCode() {
        
            return Objects.hash(name, age);
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        public Student() {
        
        }
    
        public Student(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    }

> Student\{name=‘小红’, age=36\}  
> Student\{name=‘小黑’, age=34\}  
> Student\{name=‘小蓝’, age=33\}

#### （3）HashSet集合的注意事项 ####

HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法

# 四、Map集合 #

## 1.Map集合概述 ##

interface Map<K,V>

> K：键的类型；V：值的类型

## 2.Map集合的特点 ##

*  双列集合，一个键对应一个值
 *  键不可以重复，值可以重复

## 3.Map集合的常用方法 ##

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>V put(K key,V value)</td> 
   <td>添加元素</td> 
  </tr> 
  <tr> 
   <td>V remove(Object key)</td> 
   <td>根据键删除键值对元素</td> 
  </tr> 
  <tr> 
   <td>void clear()</td> 
   <td>移除所有的键值对元素</td> 
  </tr> 
  <tr> 
   <td>boolean containsKey(Object key)</td> 
   <td>判断集合是否包含指定的键</td> 
  </tr> 
  <tr> 
   <td>boolean containsValue(Object value)</td> 
   <td>判断集合是否包含指定的值</td> 
  </tr> 
  <tr> 
   <td>boolean isEmpty()</td> 
   <td>判断集合是否为空</td> 
  </tr> 
  <tr> 
   <td>int size()</td> 
   <td>集合的长度，也就是集合中键值对的个数</td> 
  </tr> 
 </tbody> 
</table>

## 4.Map集合的获取方法 ##

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>V get(Object key)</td> 
   <td>根据键获取值</td> 
  </tr> 
  <tr> 
   <td>Set keySet()</td> 
   <td>获取所有键的集合</td> 
  </tr> 
  <tr> 
   <td>Collection values()</td> 
   <td>获取所有值的集合</td> 
  </tr> 
  <tr> 
   <td>Set&gt; entrySet()</td> 
   <td>获取所有键值对对象的集合</td> 
  </tr> 
 </tbody> 
</table>

## 5.Map集合的遍历 ##

### （一）方式1 ###

遍历思路

*  我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
    
    1.  把所有的丈夫给集中起来
    2.  遍历丈夫的集合，获取到每一个丈夫
    3.  根据丈夫去找对应的妻子

步骤分析

*  获取所有键的集合。用keySet()方法实现
 *  遍历键的集合，获取到每一个键。用增强for实现
 *  根据键去找值。用get(Object key)方法实现

import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    public class Demo {
        
        public static void main(String[] args) {
        
            Map<String, String> map = new HashMap<String, String>();
            map.put("张无忌", "赵敏");
            map.put("郭靖", "黄蓉");
            map.put("杨过", "小龙女");
            Set<String> keySet = map.keySet();
            for (String key : keySet) {
        
                String value = map.get(key);
                System.out.println(key + "," + value);
            }
        }
    }

> 杨过,小龙女  
> 郭靖,黄蓉  
> 张无忌,赵敏

### （二）方式2 ###

遍历思路

*  我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
    
    1.  获取所有结婚证的集合
    2.  遍历结婚证的集合，得到每一个结婚证
    3.  根据结婚证获取丈夫和妻子

步骤分析

*  获取所有键值对对象的集合  
    \- Set> entrySet()：获取所有键值对对象的集合
 *  遍历键值对对象的集合，得到每一个键值对对象
    
     *  用增强for实现，得到每一个Map.Entry
 *  根据键值对对象获取键和值
    
     *  用getKey()得到键
     *  用getValue()得到值

import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    public class Demo {
        
        public static void main(String[] args) {
        
            Map<String, String> map = new HashMap<String, String>();
            map.put("张无忌", "赵敏");
            map.put("郭靖", "黄蓉");
            map.put("杨过", "小龙女");
            Set<Map.Entry<String, String>> entrySet = map.entrySet();
            for (Map.Entry<String, String> me : entrySet) {
        
                String key = me.getKey();
                String value = me.getValue();
                System.out.println(key + "," + value);
            }
        }
    }

> 杨过,小龙女  
> 郭靖,黄蓉  
> 张无忌,赵敏

## 6.HashMap集合 ##

### （一）HashMap集合的特点 ###

*  HashMap底层是哈希表结构的
 *  依赖hashCode方法和equals方法保证键的唯一
 *  如果键要存储的是自定义对象，需要重写hashCode和equals方法

### （二）HashMap集合的代码实例 ###

import java.util.Collection;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    public class Demo2 {
        
        public static void main(String[] args) {
        
            Map<String, String> map = new HashMap<>();
            map.put("001", "大黄");
            map.put("004", "小黄");
            map.put("003", "小田");
            map.put("002", "大田");
            System.out.println(map);
            System.out.println("__");
            System.out.println(map);
            System.out.println("__");
            System.out.println(map.isEmpty());
            System.out.println(map.containsKey("004"));
            System.out.println(map.containsValue("啊啊"));
            String remove = map.remove("004");
            System.out.println(remove);
            System.out.println("__");
            System.out.println(map);
            System.out.println(map.size());
            System.out.println("__");
            Set<String> strings = map.keySet();
            for (String string : strings) {
        
                System.out.println(string);
            }
            System.out.println("__");
            Collection<String> values = map.values();
            for (String value : values) {
        
                System.out.println(value);
            }
        }
    }

> \{001=大黄, 002=大田, 003=小田, 004=小黄\}  
> \_\_  
> \{001=大黄, 002=大田, 003=小田, 004=小黄\}  
> \_\_  
> false  
> true  
> false  
> 小黄  
> \_\_  
> \{001=大黄, 002=大田, 003=小田\}  
> 3  
> \_\_  
> 001  
> 002  
> 003  
> \_\_  
> 大黄  
> 大田  
> 小田

## 7.HashMap集合 ##

### （一）TreeMap集合的特点 ###

*  TreeMap底层是红黑树结构
 *  依赖自然排序或者比较器排序,对键进行排序
 *  如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则

### （二）TreeMap集合的代码实例 ###

案例需求

*  创建一个TreeMap集合,键是学生对象(Student),值是籍贯(String),学生属性姓名和年龄,按照年龄进行排序并遍历
 *  要求按照学生的年龄进行排序,如果年龄相同则按照姓名进行排序

import java.util.TreeMap;
    
    public class Demo {
        
        public static void main(String[] args) {
        
            TreeMap<Student, String> tm = new TreeMap<>();
            Student s1 = new Student("xiaohei", 23);
            Student s2 = new Student("dapang", 22);
            Student s3 = new Student("xiaomei", 22);
            tm.put(s1, "江苏");
            tm.put(s2, "北京");
            tm.put(s3, "天津");
            tm.forEach(
                    (Student key, String value) -> {
        
                        System.out.println(key + "‐‐‐" + value);
                    }
            );
        }
    }
    
    class Student implements Comparable<Student> {
        
        private String name;
        private int age;
    
        public Student() {
        
        }
    
        public Student(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        @Override
        public int compareTo(Student o) {
        
            int result = o.getAge() - this.getAge();
            result = result == 0 ? o.getName().compareTo(this.getName()) : result;
            return result;
        }
    }

> Student\{name=‘xiaohei’, age=23\}‐‐‐江苏  
> Student\{name=‘xiaomei’, age=22\}‐‐‐天津  
> Student\{name=‘dapang’, age=22\}‐‐‐北京

--------------------

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjAwNjk4OA_size_16_color_FFFFFF_t_70]: /images/20221120/165b7698980d41f2b6f70bcff1b737a8.png
[ArrayList_2020]: https://blog.csdn.net/weixin_46006988/article/details/109695771