JAVA集合进阶-人工智能-PHP中文网

### 1.collection集合

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

- 相同点

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

- 不同点

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

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

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

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

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

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

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

- Collection集合概述

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

- 创建Collection集合的对象

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

- Collection集合常用方法

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

- 迭代器介绍

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

- Iterator中的常用方法

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

- Collection集合的遍历

```java public class IteratorDemo1 { public static void main(String[] args) { //创建集合对象 Collectionu003cStringu003e c = new ArrayListu003cu003e(); //添加元素 c.add("hello"); c.add("world"); c.add("java"); c.add("javaee"); //Iteratoru003cEu003e iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到 Iteratoru003cStringu003e 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) { ArrayListu003cStringu003e list = new ArrayListu003cu003e(); list.add("a"); list.add("b"); list.add("b"); list.add("c"); list.add("d"); Iteratoru003cStringu003e 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) { ArrayListu003cStringu003e list = new ArrayListu003cu003e(); 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) { Listu003cStringu003e list = new ArrayListu003cu003e(); list.add("aaa"); list.add("bbb"); list.add("ccc"); //method1(list); //method2(list); //method3(list); //method4(list); } private static void method4(Listu003cStringu003e list) { // E get(int index) 返回指定索引处的元素 String s = list.get(0); System.out.println(s); } private static void method3(Listu003cStringu003e 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(Listu003cStringu003e list) { // E remove(int index) 删除指定索引处的元素，返回被删除的元素 //在List集合中有两个删除的方法 //第一个删除指定的元素,返回值表示当前元素是否删除成功 //第二个删除指定索引的元素,返回值表示实际删除的元素 String s = list.remove(0); System.out.println(s); System.out.println(list); } private static void method1(Listu003cStringu003e 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) { LinkedListu003cStringu003e list = new LinkedListu003cu003e(); 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(LinkedListu003cStringu003e 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(LinkedListu003cStringu003e list) { String first = list.getFirst(); String last = list.getLast(); System.out.println(first); System.out.println(last); } private static void method2(LinkedListu003cStringu003e list) { list.addLast("www"); System.out.println(list); } private static void method1(LinkedListu003cStringu003e list) { list.addFirst("qqq"); System.out.println(list); } } ```

### 4.泛型

#### 4.1泛型概述

- 泛型的介绍

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

- 泛型的好处

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

- 泛型的定义格式

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

### 5.Set集合

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

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

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

存储字符串并遍历

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

// for (int i = 0; i u003c set.size(); i++) {// //Set集合是没有索引的，所以不能使用通过索引获取元素的方法// } //遍历集合 Iteratoru003cStringu003e 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) { //创建集合对象 TreeSetu003cIntegeru003e ts = new TreeSetu003cIntegeru003e();

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

ts.add(30);

JTopCms建站系统

JTopCMS基于JavaEE自主研发，是用于管理站群内容的国产开源软件(CMS)，能高效便捷地进行内容采编，审核，模板制作，用户交互以及文件等资源的维护。安全，稳定，易扩展，支持国产中间件及数据库，适合建设政府，教育以及企事业单位的站群系统。系统特色 1. 基于 JAVA 标准自主研发，支持主流国产信创环境，国产数据库以及国产中间件。安全，稳定，经过多次政务与企事业单位项目长期检验，顺利通过

查看详情

//遍历集合 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 Comparableu003cStudentu003e{ 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) { //创建集合对象 TreeSetu003cStudentu003e ts = new TreeSetu003cu003e(); //创建学生对象 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) { //创建集合对象 TreeSetu003cTeacheru003e ts = new TreeSetu003cu003e(new Comparatoru003cTeacheru003e() { @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 Mapu003cK,Vu003e K：键的类型；V：值的类型 ```

- Map集合的特点

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

- Map集合的基本使用

```java public class MapDemo01 { public static void main(String[] args) { //创建集合对象 Mapu003cString,Stringu003e map = new HashMapu003cString,Stringu003e(); //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) { //创建集合对象 Mapu003cString,Stringu003e map = new HashMapu003cString,Stringu003e(); //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) | 根据键获取值 | | Setu003cKu003e keySet() | 获取所有键的集合 | | Collectionu003cVu003e values() | 获取所有值的集合 | | Setu003cMap.Entryu003cK,Vu003eu003e entrySet() | 获取所有键值对对象的集合 |

- 示例代码

```java public class MapDemo03 { public static void main(String[] args) { //创建集合对象 Mapu003cString, Stringu003e map = new HashMapu003cString, Stringu003e(); //添加元素 map.put("张无忌", "赵敏"); map.put("郭靖", "黄蓉"); map.put("杨过", "小龙女"); //V get(Object key):根据键获取值 // System.out.println(map.get("张无忌")); // System.out.println(map.get("张三丰")); //Setu003cKu003e keySet():获取所有键的集合 // Setu003cStringu003e keySet = map.keySet(); // for(String key : keySet) { // System.out.println(key); // } //Collectionu003cVu003e values():获取所有值的集合 Collectionu003cStringu003e 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) { //创建集合对象 Mapu003cString, Stringu003e map = new HashMapu003cString, Stringu003e(); //添加元素 map.put("张无忌", "赵敏"); map.put("郭靖", "黄蓉"); map.put("杨过", "小龙女"); //获取所有键的集合。用keySet()方法实现 Setu003cStringu003e 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看成是一个夫妻对的集合 - 获取所有结婚证的集合 - 遍历结婚证的集合，得到每一个结婚证 - 根据结婚证获取丈夫和妻子

- 步骤分析

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

- 代码实现

```java public class MapDemo02 { public static void main(String[] args) { //创建集合对象 Mapu003cString, Stringu003e map = new HashMapu003cString, Stringu003e(); //添加元素 map.put("张无忌", "赵敏"); map.put("郭靖", "黄蓉"); map.put("杨过", "小龙女"); //获取所有键值对对象的集合 Setu003cMap.Entryu003cString, Stringu003eu003e entrySet = map.entrySet(); //遍历键值对对象的集合，得到每一个键值对对象 for (Map.Entryu003cString, Stringu003e 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集合对象 HashMapu003cStudent, Stringu003e hm = new HashMapu003cStudent, Stringu003e(); //创建学生对象 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, "北京"); //遍历集合 Setu003cStudentu003e 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 Comparableu003cStudentu003e{ 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集合对象 TreeMapu003cStudent,Stringu003e tm = new TreeMapu003cu003e(); // 创建学生对象 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); } ); } } ```

以上就是JAVA集合进阶的详细内容，更多请关注php中文网其它相关文章！