JAVA集合进阶

### 1.collection集合

#### 1.1数组和集合的区别【理解】

- 相同点

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

- 不同点

立即学习“Java免费学习笔记（深入）”；

- 数组的长度是不可变的,集合的长度是可变的

- 数组可以存基本数据类型和引用数据类型

集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

#### 1.2集合类体系结构【理解】

☞☞☞AI 智能聊天, 问答助手, AI 智能搜索, 免费无限量使用 DeepSeek R1 模型☜☜☜

#### 1.3Collection 集合概述和使用【应用】

- Collection集合概述

- 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素 - JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现

- 创建Collection集合的对象

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

- Collection集合常用方法

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

#### 1.4Collection集合的遍历【应用】

- 迭代器介绍

- 迭代器,集合的专用遍历方式 - Iterator\u003cE\u003e iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到

- Iterator中的常用方法

​ boolean hasNext(): 判断当前位置是否有元素可以被取出 ​ E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

- Collection集合的遍历

```java public class IteratorDemo1 { public static void main(String[] args) { //创建集合对象 Collection\u003cString\u003e c = new ArrayList\u003c\u003e(); //添加元素 c.add(\"hello\"); c.add(\"world\"); c.add(\"java\"); c.add(\"javaee\"); //Iterator\u003cE\u003e iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到 Iterator\u003cString\u003e it = c.iterator(); //用while循环改进元素的判断和获取 while (it.hasNext()) { String s = it.next(); System.out.println(s); } } } ```

- 迭代器中删除的方法

​ void remove(): 删除迭代器对象当前指向的元素

```java public class IteratorDemo2 { public static void main(String[] args) { ArrayList\u003cString\u003e list = new ArrayList\u003c\u003e(); list.add(\"a\"); list.add(\"b\"); list.add(\"b\"); list.add(\"c\"); list.add(\"d\"); Iterator\u003cString\u003e it = list.iterator(); while(it.hasNext()){ String s = it.next(); if(\"b\".equals(s)){ //指向谁,那么此时就删除谁. it.remove(); } } System.out.println(list); } } ```

#### 1.5增强for循环【应用】

- 介绍

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

- 格式

​ for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {

​ // 已经将当前遍历到的元素封装到变量中了,直接使用变量即可

​ }

- 代码

```java public class MyCollectonDemo1 { public static void main(String[] args) { ArrayList\u003cString\u003e list = new ArrayList\u003c\u003e(); list.add(\"a\"); list.add(\"b\"); list.add(\"c\"); list.add(\"d\"); list.add(\"e\"); list.add(\"f\"); //1,数据类型一定是集合或者数组中元素的类型 //2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素 //3,list就是要遍历的集合或者数组 for(String str : list){ System.out.println(str); } } } ```

### 2.List集合

#### 2.1List集合的概述和特点【记忆】

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

#### 2.2List集合的特有方法【应用】

- 方法介绍

| 方法名 | 描述 | | ------------------------------- | -------------------------------------- | | void add(int index,E element) | 在此集合中的指定位置插入指定的元素 | | E remove(int index) | 删除指定索引处的元素，返回被删除的元素 | | E set(int index,E element) | 修改指定索引处的元素，返回被修改的元素 | | E get(int index) | 返回指定索引处的元素 |

- 示例代码

```java public class MyListDemo { public static void main(String[] args) { List\u003cString\u003e list = new ArrayList\u003c\u003e(); list.add(\"aaa\"); list.add(\"bbb\"); list.add(\"ccc\"); //method1(list); //method2(list); //method3(list); //method4(list); } private static void method4(List\u003cString\u003e list) { // E get(int index) 返回指定索引处的元素 String s = list.get(0); System.out.println(s); } private static void method3(List\u003cString\u003e list) { // E set(int index,E element) 修改指定索引处的元素，返回被修改的元素 //被替换的那个元素,在集合中就不存在了. String result = list.set(0, \"qqq\"); System.out.println(result); System.out.println(list); } private static void method2(List\u003cString\u003e list) { // E remove(int index) 删除指定索引处的元素，返回被删除的元素 //在List集合中有两个删除的方法 //第一个 删除指定的元素,返回值表示当前元素是否删除成功 //第二个 删除指定索引的元素,返回值表示实际删除的元素 String s = list.remove(0); System.out.println(s); System.out.println(list); } private static void method1(List\u003cString\u003e list) { // void add(int index,E element) 在此集合中的指定位置插入指定的元素 //原来位置上的元素往后挪一个索引. list.add(0,\"qqq\"); System.out.println(list); } } ```

### 3.List集合的实现类

#### 3.1List集合子类的特点【记忆】

- ArrayList集合

​ 底层是**数组**结构实现，查询快、增删慢

- LinkedList集合

​ 底层是**链表**结构实现，查询慢、增删快

#### 3.2LinkedList集合的特有功能【应用】

- 特有方法

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

- 示例代码

```java public class MyLinkedListDemo4 { public static void main(String[] args) { LinkedList\u003cString\u003e list = new LinkedList\u003c\u003e(); list.add(\"aaa\"); list.add(\"bbb\"); list.add(\"ccc\"); // public void addFirst(E e) 在该列表开头插入指定的元素 //method1(list); // public void addLast(E e) 将指定的元素追加到此列表的末尾 //method2(list); // public E getFirst() 返回此列表中的第一个元素 // public E getLast() 返回此列表中的最后一个元素 //method3(list); // public E removeFirst() 从此列表中删除并返回第一个元素 // public E removeLast() 从此列表中删除并返回最后一个元素 //method4(list); } private static void method4(LinkedList\u003cString\u003e list) { String first = list.removeFirst(); System.out.println(first); String last = list.removeLast(); System.out.println(last); System.out.println(list); } private static void method3(LinkedList\u003cString\u003e list) { String first = list.getFirst(); String last = list.getLast(); System.out.println(first); System.out.println(last); } private static void method2(LinkedList\u003cString\u003e list) { list.addLast(\"www\"); System.out.println(list); } private static void method1(LinkedList\u003cString\u003e list) { list.addFirst(\"qqq\"); System.out.println(list); } } ```

### 4.泛型

#### 4.1泛型概述

- 泛型的介绍

​ 泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制

- 泛型的好处

1. 把运行时期的问题提前到了编译期间 2. 避免了强制类型转换

- 泛型的定义格式

- \u003c类型\u003e: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母.例如: \u003cE\u003e \u003cT\u003e - \u003c类型1,类型2…\u003e: 指定多种类型的格式,多种类型之间用逗号隔开.例如: \u003cE,T\u003e \u003cK,V\u003e

### 5.Set集合

#### 5.1 Set集合概述和特点【应用】

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

#### 5.2 Set集合的使用【应用】

存储字符串并遍历

```javapublic class MySet1 { public static void main(String[] args) { //创建集合对象 Set\u003cString\u003e set = new TreeSet\u003c\u003e(); //添加元素 set.add(\"ccc\"); set.add(\"aaa\"); set.add(\"aaa\"); set.add(\"bbb\");

// for (int i = 0; i \u003c set.size(); i++) {// //Set集合是没有索引的，所以不能使用通过索引获取元素的方法// } //遍历集合 Iterator\u003cString\u003e it = set.iterator(); while (it.hasNext()){ String s = it.next(); System.out.println(s); } System.out.println(\"-----------------------------------\"); for (String s : set) { System.out.println(s); } }}```

### 6.TreeSet集合

#### 6.1TreeSet集合概述和特点【应用】

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

#### 6.2TreeSet集合基本使用【应用】

存储Integer类型的整数并遍历

```javapublic class TreeSetDemo01 { public static void main(String[] args) { //创建集合对象 TreeSet\u003cInteger\u003e ts = new TreeSet\u003cInteger\u003e();

//添加元素 ts.add(10); ts.add(40); ts.add(30); ts.add(50); ts.add(20);

ts.add(30);

动易网上商城管理系统 2006 Sp6 Build 1120 普及版

将产品展示、购物管理、资金管理等功能相结合，并提供了简易的操作、丰富的功能和完善的权限管理，为用户提供了一个低成本、高效率的网上商城建设方案包含PowerEasy CMS普及版，主要功能模块：文章频道、下载频道、图片频道、留言频道、采集管理、商城模块、商城日常操作模块500个订单限制（超出限制后只能查看和删除，不能进行其他处理） 无订单处理权限分配功能（只有超级管理员才能处理订单）

下载

//遍历集合 for(Integer i : ts) { System.out.println(i); } }}```

#### 6.3自然排序Comparable的使用【应用】

- 案例需求

- 存储学生对象并遍历，创建TreeSet集合使用无参构造方法 - 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

- 实现步骤

1. 使用空参构造创建TreeSet集合 + 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的 2. 自定义的Student类实现Comparable接口 + 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法 3. 重写接口中的compareTo方法 + 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

- 代码实现

学生类

```java public class Student implements Comparable\u003cStudent\u003e{ 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 = this.age - o.age; //次要判断条件: 年龄相同时，按照姓名的字母顺序排序 result = result == 0 ? this.name.compareTo(o.getName()) : result; return result; } } ```

测试类

```java public class MyTreeSet2 { public static void main(String[] args) { //创建集合对象 TreeSet\u003cStudent\u003e ts = new TreeSet\u003c\u003e(); //创建学生对象 Student s1 = new Student(\"zhangsan\",28); Student s2 = new Student(\"lisi\",27); Student s3 = new Student(\"wangwu\",29); Student s4 = new Student(\"zhaoliu\",28); Student s5 = new Student(\"qianqi\",30); //把学生添加到集合 ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); //遍历集合 for (Student student : ts) { System.out.println(student); } } } ```

#### 6.4比较器排序Comparator的使用【应用】

- 案例需求

- 存储老师对象并遍历，创建TreeSet集合使用带参构造方法 - 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

- 实现步骤

- 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的 - 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法 - 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

- 代码实现

老师类

```java public class Teacher { private String name; private int age; public Teacher() { } public Teacher(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 \"Teacher{\" + \"name='\" + name + '\\'' + \", age=\" + age + '}'; } } ```

测试类

```java public class MyTreeSet4 { public static void main(String[] args) { //创建集合对象 TreeSet\u003cTeacher\u003e ts = new TreeSet\u003c\u003e(new Comparator\u003cTeacher\u003e() { @Override public int compare(Teacher o1, Teacher o2) { //o1表示现在要存入的那个元素 //o2表示已经存入到集合中的元素 //主要条件 int result = o1.getAge() - o2.getAge(); //次要条件 result = result == 0 ? o1.getName().compareTo(o2.getName()) : result; return result; } }); //创建老师对象 Teacher t1 = new Teacher(\"zhangsan\",23); Teacher t2 = new Teacher(\"lisi\",22); Teacher t3 = new Teacher(\"wangwu\",24); Teacher t4 = new Teacher(\"zhaoliu\",24); //把老师添加到集合 ts.add(t1); ts.add(t2); ts.add(t3); ts.add(t4); //遍历集合 for (Teacher teacher : ts) { System.out.println(teacher); } } } ```

#### 6.5两种比较方式总结【理解】

+ 两种比较方式小结 + 自然排序: 自定义类实现Comparable接口,重写compareTo方法,根据返回值进行排序 + 比较器排序: 创建TreeSet对象的时候传递Comparator的实现类对象,重写compare方法,根据返回值进行排序 + 在使用的时候,默认使用自然排序,当自然排序不满足现在的需求时,必须使用比较器排序+ 两种方式中关于返回值的规则 + 如果返回值为负数，表示当前存入的元素是较小值，存左边 + 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存 + 如果返回值为正数，表示当前存入的元素是较大值，存右边

### 7.Map集合

#### 7.1Map集合概述和特点【理解】

- Map集合概述

```java interface Map\u003cK,V\u003e K：键的类型；V：值的类型 ```

- Map集合的特点

- 双列集合,一个键对应一个值 - 键不可以重复,值可以重复

- Map集合的基本使用

```java public class MapDemo01 { public static void main(String[] args) { //创建集合对象 Map\u003cString,String\u003e map = new HashMap\u003cString,String\u003e(); //V put(K key, V value) 将指定的值与该映射中的指定键相关联 map.put(\"zzz001\",\"林青霞\"); map.put(\"zzz002\",\"张曼玉\"); map.put(\"zzz003\",\"王祖贤\"); map.put(\"zzz003\",\"柳岩\"); //输出集合对象 System.out.println(map); } } ```

#### 7.2Map集合的基本功能【应用】

- 方法介绍

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

- 示例代码

```java public class MapDemo02 { public static void main(String[] args) { //创建集合对象 Map\u003cString,String\u003e map = new HashMap\u003cString,String\u003e(); //V put(K key,V value)：添加元素 map.put(\"张无忌\",\"赵敏\"); map.put(\"郭靖\",\"黄蓉\"); map.put(\"杨过\",\"小龙女\"); //V remove(Object key)：根据键删除键值对元素 // System.out.println(map.remove(\"郭靖\")); // System.out.println(map.remove(\"郭襄\")); //void clear()：移除所有的键值对元素 // map.clear(); //boolean containsKey(Object key)：判断集合是否包含指定的键 // System.out.println(map.containsKey(\"郭靖\")); // System.out.println(map.containsKey(\"郭襄\")); //boolean isEmpty()：判断集合是否为空 // System.out.println(map.isEmpty()); //int size()：集合的长度，也就是集合中键值对的个数 System.out.println(map.size()); //输出集合对象 System.out.println(map); } } ```

#### 7.3Map集合的获取功能【应用】

- 方法介绍

| 方法名 | 说明 | | -------------------------------- | ------------------------ | | V get(Object key) | 根据键获取值 | | Set\u003cK\u003e keySet() | 获取所有键的集合 | | Collection\u003cV\u003e values() | 获取所有值的集合 | | Set\u003cMap.Entry\u003cK,V\u003e\u003e entrySet() | 获取所有键值对对象的集合 |

- 示例代码

```java public class MapDemo03 { public static void main(String[] args) { //创建集合对象 Map\u003cString, String\u003e map = new HashMap\u003cString, String\u003e(); //添加元素 map.put(\"张无忌\", \"赵敏\"); map.put(\"郭靖\", \"黄蓉\"); map.put(\"杨过\", \"小龙女\"); //V get(Object key):根据键获取值 // System.out.println(map.get(\"张无忌\")); // System.out.println(map.get(\"张三丰\")); //Set\u003cK\u003e keySet():获取所有键的集合 // Set\u003cString\u003e keySet = map.keySet(); // for(String key : keySet) { // System.out.println(key); // } //Collection\u003cV\u003e values():获取所有值的集合 Collection\u003cString\u003e values = map.values(); for(String value : values) { System.out.println(value); } } } ```

#### 7.4Map集合的遍历(方式1)【应用】

- 遍历思路

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

- 步骤分析

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

- 代码实现

```java public class MapDemo01 { public static void main(String[] args) { //创建集合对象 Map\u003cString, String\u003e map = new HashMap\u003cString, String\u003e(); //添加元素 map.put(\"张无忌\", \"赵敏\"); map.put(\"郭靖\", \"黄蓉\"); map.put(\"杨过\", \"小龙女\"); //获取所有键的集合。用keySet()方法实现 Set\u003cString\u003e keySet = map.keySet(); //遍历键的集合，获取到每一个键。用增强for实现 for (String key : keySet) { //根据键去找值。用get(Object key)方法实现 String value = map.get(key); System.out.println(key + \",\" + value); } } } ```

#### 7.5Map集合的遍历(方式2)【应用】

- 遍历思路

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

- 步骤分析

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

- 代码实现

```java public class MapDemo02 { public static void main(String[] args) { //创建集合对象 Map\u003cString, String\u003e map = new HashMap\u003cString, String\u003e(); //添加元素 map.put(\"张无忌\", \"赵敏\"); map.put(\"郭靖\", \"黄蓉\"); map.put(\"杨过\", \"小龙女\"); //获取所有键值对对象的集合 Set\u003cMap.Entry\u003cString, String\u003e\u003e entrySet = map.entrySet(); //遍历键值对对象的集合，得到每一个键值对对象 for (Map.Entry\u003cString, String\u003e me : entrySet) { //根据键值对对象获取键和值 String key = me.getKey(); String value = me.getValue(); System.out.println(key + \",\" + value); } } } ```

### 8.HashMap集合

#### 8.1HashMap集合概述和特点【理解】

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

#### 8.2HashMap集合应用案例【应用】

- 案例需求

- 创建一个HashMap集合，键是学生对象(Student)，值是居住地 (String)。存储多个元素，并遍历。 - 要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象

- 代码实现

学生类

```java public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Student student = (Student) o; if (age != student.age) return false; return name != null ? name.equals(student.name) : student.name == null; } @Override public int hashCode() { int result = name != null ? name.hashCode() : 0; result = 31 * result + age; return result; } } ```

测试类

```java public class HashMapDemo { public static void main(String[] args) { //创建HashMap集合对象 HashMap\u003cStudent, String\u003e hm = new HashMap\u003cStudent, String\u003e(); //创建学生对象 Student s1 = new Student(\"林青霞\", 30); Student s2 = new Student(\"张曼玉\", 35); Student s3 = new Student(\"王祖贤\", 33); Student s4 = new Student(\"王祖贤\", 33); //把学生添加到集合 hm.put(s1, \"西安\"); hm.put(s2, \"武汉\"); hm.put(s3, \"郑州\"); hm.put(s4, \"北京\"); //遍历集合 Set\u003cStudent\u003e keySet = hm.keySet(); for (Student key : keySet) { String value = hm.get(key); System.out.println(key.getName() + \",\" + key.getAge() + \",\" + value); } } } ```

### 9.TreeMap集合

#### 9.1TreeMap集合概述和特点【理解】

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

#### 9.2TreeMap集合应用案例【应用】

+ 案例需求

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

+ 代码实现

学生类

```java public class Student implements Comparable\u003cStudent\u003e{ 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; } } ```

测试类

```java public class Test1 { public static void main(String[] args) { // 创建TreeMap集合对象 TreeMap\u003cStudent,String\u003e tm = new TreeMap\u003c\u003e(); // 创建学生对象 Student s1 = new Student(\"xiaohei\",23); Student s2 = new Student(\"dapang\",22); Student s3 = new Student(\"xiaomei\",22); // 将学生对象添加到TreeMap集合中 tm.put(s1,\"江苏\"); tm.put(s2,\"北京\"); tm.put(s3,\"天津\"); // 遍历TreeMap集合,打印每个学生的信息 tm.forEach( (Student key, String value)-\u003e{ System.out.println(key + \"---\" + value); } ); } } ```