Java集合技术（小白入门必学）

Java 集合框架（Collections Framework）是 Java 提供的一组用于存储和操作对象组的接口和类。集合框架主要包括以下几部分：

• Collection接口：集合框架的根接口
• List接口：有序集合，允许元素重复
• Set接口：无序集合，不允许元素重复
• Queue接口：队列，用于按特定顺序处理元素
• Map接口：键值对映射，键唯一，值可以重复

---

1.Collection集合

        Collection 是集合框架的根接口，定义了所有集合共有的方法

// 导入 Java 集合框架中的 Collection 接口和 ArrayList 类
// Collection 是所有集合类的根接口，定义了集合的基本操作，如添加、删除、检查元素等
// ArrayList 是 Collection 接口的一个具体实现，基于动态数组实现，可动态调整大小
import java.util.Collection;
import java.util.ArrayList;

// 定义一个名为 CollectionExample 的公共类，用于演示集合的基本操作
public class CollectionExample {
    // 程序的入口方法，Java 程序从这里开始执行
    public static void main(String[] args) {
        // 创建一个泛型集合实例，指定集合中存储的元素类型为 String
        // 使用 ArrayList 作为 Collection 接口的具体实现
        // 这样可以利用 ArrayList 的动态数组特性来存储和操作元素
        Collection<String> collection = new ArrayList<>();

        // 向集合添加三个水果元素
        // add 方法用于将指定元素添加到集合中
        collection.add("Apple");  // 添加苹果到集合中
        collection.add("Banana"); // 添加香蕉到集合中
        collection.add("Cherry"); // 添加樱桃到集合中

        // 打印集合当前元素数量
        // size() 方法用于返回集合中元素的数量
        System.out.println("Size: " + collection.size()); // 输出：3

        // 检查集合是否为空
        // isEmpty() 方法用于判断集合是否不包含任何元素
        System.out.println("Is the collection empty? " + collection.isEmpty()); // 输出：false

        // 检查集合是否包含特定元素
        // contains() 方法用于判断集合中是否包含指定的元素
        System.out.println("Contains 'Banana': " + collection.contains("Banana")); // 输出：true

        // 使用增强 for 循环遍历集合中的元素
        System.out.println("Elements in the collection:");
        // 增强 for 循环会依次取出集合中的每个元素并赋值给 element 变量
        for (String element : collection) {
            // 打印当前遍历到的元素
            System.out.println(element);
        }
        // 输出：
        // Elements in the collection:
        // Apple
        // Banana
        // Cherry

        // 从集合中移除指定元素
        // remove() 方法用于移除集合中首次出现的指定元素
        collection.remove("Apple");
        // 显示移除后的集合状态
        System.out.println("After removing 'Apple': " + collection); // 输出：[Banana, Cherry]

        // 向集合中添加一个重复元素
        // 由于 ArrayList 允许存储重复元素，所以可以再次添加 "Banana"
        collection.add("Banana");
        System.out.println("After adding a duplicate 'Banana': " + collection); // 输出：[Banana, Cherry, Banana]

        // 将集合转换为数组
        // toArray() 方法将集合中的元素复制到一个新数组中
        Object[] array = collection.toArray();
        System.out.print("Collection converted to array: ");
        // 遍历数组中的每个元素
        for (Object obj : array) {
            // 打印数组中的元素，元素之间用空格分隔
            System.out.print(obj + " ");
        }
        System.out.println(); // 输出：Collection converted to array: Banana Cherry Banana

        // 清空集合中的所有元素
        // clear() 方法移除集合中的所有元素
        collection.clear();
        System.out.println("After clearing the collection: " + collection); // 输出：[]

        // 再次检查集合是否为空
        System.out.println("Is the collection empty after clearing? " + collection.isEmpty()); // 输出：true
    }
}
//运行结果
Size: 3  // 调用 size() 方法输出集合中元素的数量，此时集合中有 Apple、Banana、Cherry 三个元素
Is the collection empty? false  // 调用 isEmpty() 方法检查集合是否为空，由于有元素，所以返回 false
Contains 'Banana': true  // 调用 contains() 方法检查集合中是否包含 "Banana"，存在则返回 true
Elements in the collection:  // 提示开始输出集合中的元素
Apple  // 增强 for 循环遍历集合，输出第一个元素
Banana  // 输出第二个元素
Cherry  // 输出第三个元素
After removing 'Apple': [Banana, Cherry]  // 调用 remove() 方法移除 "Apple" 后，输出集合剩余元素
After adding a duplicate 'Banana': [Banana, Cherry, Banana]  // 再次添加 "Banana" 后，输出集合元素，ArrayList 允许重复元素
Collection converted to array: Banana Cherry Banana  // 调用 toArray() 方法将集合转换为数组并输出数组元素
After clearing the collection: []  // 调用 clear() 方法清空集合后，输出集合内容，此时为空
Is the collection empty after clearing? true  // 再次调用 isEmpty() 方法检查集合是否为空，清空后返回 true

2.List接口

        List 是有序集合，允许重复元素。常用的实现类有 ArrayList 和 LinkedList

// 导入 java.util 包中的 List 接口，List 是一个有序的集合接口，允许元素重复，可通过索引访问元素
import java.util.List;
// 导入 java.util 包中的 ArrayList 类，ArrayList 是 List 接口的一个动态数组实现类
import java.util.ArrayList;

// 定义一个名为 ListExample 的公共类，用于演示 List 集合的操作
public class ListExample {
    // 程序的入口点，Java 程序从 main 方法开始执行
    public static void main(String[] args) {
        // 创建一个字符串类型的 ArrayList 实例，通过 List 接口引用
        // 这样做遵循了面向接口编程的原则，提高了代码的可维护性和可扩展性
        // 这里创建了一个空的列表，用于存储 String 类型的元素
        List<String> list = new ArrayList<>();

        // 往列表添加三个元素
        // add 方法用于在列表末尾添加元素
        // 向列表中添加 "Apple" 元素，该元素在列表中的索引为 0
        list.add("Apple");
        // 向列表中添加 "Banana" 元素，该元素在列表中的索引为 1
        list.add("Banana");
        // 向列表中添加 "Cherry" 元素，该元素在列表中的索引为 2
        list.add("Cherry");

        // 打印列表的初始状态
        // 输出当前列表中所有元素的内容，直观展示列表添加元素后的初始情况
        System.out.println("初始列表内容: " + list);

        // 获取并打印索引 1 的元素（第二个元素）
        // get 方法根据指定的索引返回列表中的元素
        // 从列表中获取索引为 1 的元素并打印输出，列表索引从 0 开始计数
        System.out.println("索引 1 处的元素: " + list.get(1)); // 输出 Banana

        // 检查列表中是否包含特定元素
        // contains 方法用于判断列表中是否包含指定的元素
        // 判断列表中是否存在 "Banana" 元素，并将结果存储在 containsBanana 变量中
        boolean containsBanana = list.contains("Banana");
        // 输出列表中是否包含 "Banana" 元素的检查结果
        System.out.println("列表中是否包含 'Banana': " + containsBanana);

        // 修改索引 1 的元素为 Blueberry
        // set 方法用于替换指定索引处的元素
        // 将列表中索引为 1 的元素替换为 "Blueberry"
        list.set(1, "Blueberry");
        // 输出修改元素后列表的内容，展示修改操作的结果
        System.out.println("将索引 1 的元素设置为 'Blueberry' 后: " + list); // [Apple, Blueberry, Cherry]

        // 获取列表的大小（元素数量）
        // size 方法返回列表中元素的数量
        // 调用 size 方法获取列表中当前元素的数量，并将结果存储在 size 变量中
        int size = list.size();
        // 输出列表当前的元素数量
        System.out.println("当前列表的大小: " + size);

        // 删除索引 2 的元素（第三个元素）
        // remove 方法根据索引删除列表中的元素
        // 从列表中移除索引为 2 的元素
        list.remove(2);
        // 输出删除元素后列表的内容，展示删除操作的结果
        System.out.println("删除索引 2 的元素后: " + list); // 输出 [Apple, Blueberry]

        // 检查列表是否为空
        // isEmpty 方法用于判断列表是否不包含任何元素
        // 判断列表是否为空，并将结果存储在 isEmpty 变量中
        boolean isEmpty = list.isEmpty();
        // 输出列表是否为空的检查结果
        System.out.println("列表是否为空: " + isEmpty);

        // 在指定索引位置插入元素
        // add 方法的重载形式，用于在指定索引处插入元素
        // 在列表的索引 1 位置插入 "Strawberry" 元素，后续元素索引依次后移
        list.add(1, "Strawberry");
        // 输出插入元素后列表的内容，展示插入操作的结果
        System.out.println("在索引 1 处插入 'Strawberry' 后: " + list);

        // 遍历列表元素
        // 使用增强 for 循环遍历列表中的所有元素
        // 输出提示信息，表示开始遍历列表元素
        System.out.println("遍历列表元素:");
        // 增强 for 循环，依次取出列表中的每个元素并赋值给 element 变量
        for (String element : list) {
            // 打印当前遍历到的元素
            System.out.println(element);
        }

        // 清空列表
        // clear 方法用于移除列表中的所有元素
        // 调用 clear 方法将列表中的所有元素移除
        list.clear();
        // 输出清空列表后列表的内容，展示清空操作的结果
        System.out.println("清空列表后: " + list);

        // 再次检查列表是否为空
        // isEmpty 方法用于判断列表是否不包含任何元素
        // 再次判断列表是否为空，并将结果存储在 isEmpty 变量中
        isEmpty = list.isEmpty();
        // 输出清空操作后列表是否为空的检查结果
        System.out.println("清空后列表是否为空: " + isEmpty);
    }
}
//运行结果
初始列表内容: [Apple, Banana, Cherry]  // 打印出初始添加元素后列表的内容
索引 1 处的元素: Banana  // 输出索引为 1 的元素，即第二个元素
列表中是否包含 'Banana': true  // 表明列表中存在 "Banana" 元素
将索引 1 的元素设置为 'Blueberry' 后: [Apple, Blueberry, Cherry]  // 显示修改元素后的列表内容
当前列表的大小: 3  // 输出当前列表中元素的数量
删除索引 2 的元素后: [Apple, Blueberry]  // 显示删除指定索引元素后的列表内容
列表是否为空: false  // 表明列表当前不为空
在索引 1 处插入 'Strawberry' 后: [Apple, Strawberry, Blueberry]  // 显示插入元素后的列表内容
遍历列表元素:  // 提示开始遍历列表元素
Apple  // 遍历输出的第一个元素
Strawberry  // 遍历输出的第二个元素
Blueberry  // 遍历输出的第三个元素
清空列表后: []  // 显示清空列表操作后的列表内容
清空后列表是否为空: true  // 表明清空操作后列表为空

3.Set接口

        Set 是无序集合，不允许重复元素。常用的实现类有 HashSet 和 TreeSet

import java.util.Set;
import java.util.HashSet;

public class SetExample {
    public static void main(String[] args) {
        // 创建一个 Set 集合，使用 HashSet 作为实现类，泛型指定集合存储的元素类型为 String
        Set<String> set = new HashSet<>();

        // 向集合中添加元素
        // 添加 "Apple" 到集合中
        set.add("Apple");
        // 添加 "Banana" 到集合中
        set.add("Banana");
        // 添加 "Cherry" 到集合中
        set.add("Cherry");

        // 尝试添加重复元素，由于 Set 不允许重复元素，此操作不会使集合元素数量增加
        set.add("Apple");

        // 打印集合的初始状态
        System.out.println("初始集合内容: " + set);

        // 检查集合中是否包含特定元素
        // 检查集合中是否包含 "Banana"
        boolean containsBanana = set.contains("Banana");
        System.out.println("集合中是否包含 Banana: " + containsBanana);

        // 检查集合中是否包含 "Grape"
        boolean containsGrape = set.contains("Grape");
        System.out.println("集合中是否包含 Grape: " + containsGrape);

        // 从集合中删除元素
        // 删除 "Cherry" 元素
        set.remove("Cherry");
        System.out.println("删除 Cherry 后集合内容: " + set);

        // 检查集合的大小
        int size = set.size();
        System.out.println("当前集合的大小: " + size);

        // 检查集合是否为空
        boolean isEmpty = set.isEmpty();
        System.out.println("集合是否为空: " + isEmpty);

        // 清空集合
        set.clear();
        System.out.println("清空集合后内容: " + set);

        // 再次检查集合是否为空
        isEmpty = set.isEmpty();
        System.out.println("清空后集合是否为空: " + isEmpty);
    }
}

4.Queue接口

        Queue 是队列，用于按特定顺序处理元素。常用的实现类有 LinkedList 和 PriorityQueue

import java.util.Queue;
import java.util.LinkedList;

public class QueueExample {
    public static void main(String[] args) {
        // 创建一个 Queue 队列对象，使用 LinkedList 作为具体实现
        // 泛型指定队列中存储的元素类型为 String
        Queue<String> queue = new LinkedList<>();

        // 向队列中添加元素
        // 依次添加 "Apple"、"Banana" 和 "Cherry" 到队列尾部
        queue.add("Apple");
        queue.add("Banana");
        queue.add("Cherry");

        // 打印队列的初始状态
        System.out.println("初始队列内容: " + queue);

        // peek() 方法用于查看队列的头部元素，但不会将其从队列中移除
        // 输出队列的头部元素
        System.out.println("队列头部元素: " + queue.peek());

        // poll() 方法用于移除并返回队列的头部元素
        // 移除并输出队列的头部元素
        System.out.println("移除的元素: " + queue.poll());

        // 打印移除元素后队列的状态
        System.out.println("执行 poll() 操作后队列内容: " + queue);

        // 检查队列是否为空
        boolean isEmpty = queue.isEmpty();
        System.out.println("当前队列是否为空: " + isEmpty);

        // 查看队列的大小
        int size = queue.size();
        System.out.println("当前队列的大小: " + size);

        // 继续添加元素到队列
        queue.add("Date");
        System.out.println("添加 Date 后队列内容: " + queue);

        // 再次查看队列头部元素
        System.out.println("添加元素后队列头部元素: " + queue.peek());
    }
}
//代码运行结果
初始队列内容: [Apple, Banana, Cherry]
队列头部元素: Apple
移除的元素: Apple
执行 poll() 操作后队列内容: [Banana, Cherry]
当前队列是否为空: false
当前队列的大小: 2
添加 Date 后队列内容: [Banana, Cherry, Date]
添加元素后队列头部元素: Banana

5.Map接口

        Map 是键值对映射，键唯一，值可以重复。常用的实现类有 HashMap 和 TreeMap

import java.util.Map;
import java.util.HashMap;

public class MapExample {
    public static void main(String[] args) {
        // 创建一个 Map 对象，使用 HashMap 作为具体实现
        // 泛型指定键的类型为 String，值的类型为 Integer
        Map<String, Integer> map = new HashMap<>();

        // 向 Map 中添加键值对
        // 添加键为 "Apple"，值为 1 的键值对
        map.put("Apple", 1);
        // 添加键为 "Banana"，值为 2 的键值对
        map.put("Banana", 2);
        // 添加键为 "Cherry"，值为 3 的键值对
        map.put("Cherry", 3);

        // 打印初始的 Map 内容
        System.out.println("初始的 Map 内容: " + map);

        // 根据键获取对应的值
        // 获取键 "Banana" 对应的值
        Integer bananaValue = map.get("Banana");
        System.out.println("键 'Banana' 对应的值: " + bananaValue);

        // 检查 Map 中是否包含某个键
        // 检查是否包含键 "Apple"
        boolean containsApple = map.containsKey("Apple");
        System.out.println("Map 中是否包含键 'Apple': " + containsApple);

        // 移除指定键的键值对
        // 移除键为 "Apple" 的键值对
        map.remove("Apple");
        System.out.println("移除键 'Apple' 后 Map 的内容: " + map);

        // 检查移除后 Map 中是否还包含该键
        containsApple = map.containsKey("Apple");
        System.out.println("移除后 Map 中是否还包含键 'Apple': " + containsApple);

        // 修改键对应的值
        // 将键 "Banana" 对应的值修改为 5
        map.put("Banana", 5);
        System.out.println("修改键 'Banana' 的值后 Map 的内容: " + map);

        // 获取 Map 的大小（键值对的数量）
        int size = map.size();
        System.out.println("当前 Map 的大小: " + size);

        // 检查 Map 是否为空
        boolean isEmpty = map.isEmpty();
        System.out.println("当前 Map 是否为空: " + isEmpty);

        // 清空 Map
        map.clear();
        System.out.println("清空 Map 后 Map 的内容: " + map);

        // 再次检查 Map 是否为空
        isEmpty = map.isEmpty();
        System.out.println("清空后 Map 是否为空: " + isEmpty);
    }
}
//代码运行结果
初始的 Map 内容: {Apple=1, Banana=2, Cherry=3}
键 'Banana' 对应的值: 2
Map 中是否包含键 'Apple': true
移除键 'Apple' 后 Map 的内容: {Banana=2, Cherry=3}
移除后 Map 中是否还包含键 'Apple': false
修改键 'Banana' 的值后 Map 的内容: {Banana=5, Cherry=3}
当前 Map 的大小: 2
当前 Map 是否为空: false
清空 Map 后 Map 的内容: {}
清空后 Map 是否为空: true