Java 集合框架核心组件与使用场景

Java 集合框架核心组件与使用场景 | 极客日志

Java 集合框架核心组件与使用场景

7.1 学习目标与重点提示

学习目标：掌握 Java 集合框架的核心组件，包括 List、Set、Map 三种主要集合类型，了解其底层数据结构和性能特点，学会在实际开发中根据需求选择合适的集合。

重点：

List 集合的常用实现类（ArrayList、LinkedList）对比
Set 集合的常用实现类（HashSet、LinkedHashSet、TreeSet）对比
Map 集合的常用实现类（HashMap、LinkedHashMap、TreeMap）对比
集合的遍历方法（迭代器、for 循环、for-each 循环）
集合的常用操作（添加、删除、修改、查找）

7.2 集合框架概述

Java 集合框架是一个用于存储和操作对象的体系结构，提供了多种集合类型和算法。

7.2.1 集合框架的分类

定义：集合框架分为三大类：

List：有序集合，允许重复元素。
Set：无序集合，不允许重复元素。
Map：键值对集合，键不允许重复，值允许重复。

结论：集合框架分为三大类：List、Set、Map。

7.2.2 集合框架的核心接口

定义：集合框架的核心接口包括：

Collection：所有集合的根接口。
List：有序集合的接口。
Set：无序集合的接口。
Map：键值对集合的接口。

结论：集合框架的核心接口包括 Collection、List、Set、Map。

7.3 List 集合的常用实现类

List 集合是有序集合，允许重复元素。

7.3.1 ArrayList 的定义与使用

定义：ArrayList 是基于动态数组的 List 实现类。

特点：

查询效率高。
插入和删除效率低。
线程不安全。

示例：

import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {
    public static void main(String[] args) {
        // 创建 ArrayList 对象
        List<String> list = new ArrayList<>();
        
        // 添加元素
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        list.add("钱七");
        
        // 输出元素
        System.out.println("List 中的元素：" + list);
        
        // 获取元素
        String element = list.get(2);
        System.out.println("索引为 2 的元素：" + element);
        
        // 修改元素
        list.set(2, "王五（修改后）");
        System.out.println("修改后的 List：" + list);
        
        // 删除元素
        list.remove(2);
        System.out.println("删除索引为 2 的元素后的 List：" + list);
        
        // 遍历元素 (for 循环)
        System.out.println("遍历 List 中的元素：");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        
        // 遍历元素 (for-each 循环)
        System.out.println("遍历 List 中的元素（for-each 循环）：");
        for (String s : list) {
            System.out.println(s);
        }
    }
}

输出结果：

List 中的元素：[张三，李四，王五，赵六，钱七]
索引为 2 的元素：王五
修改后的 List：[张三，李四，王五（修改后），赵六，钱七]
删除索引为 2 的元素后的 List：[张三，李四，赵六，钱七]
遍历 List 中的元素：
张三
李四
赵六
钱七
遍历 List 中的元素（for-each 循环）：
张三
李四
赵六
钱七

结论：ArrayList 是基于动态数组的 List 实现类，查询效率高，插入和删除效率低，线程不安全。

7.3.2 LinkedList 的定义与使用

定义：LinkedList 是基于双向链表的 List 实现类。

特点：

查询效率低。
插入和删除效率高。
线程不安全。

示例：

import java.util.LinkedList;
import java.util.List;

public class LinkedListExample {
    public static void main(String[] args) {
        // 创建 LinkedList 对象
        List<String> list = new LinkedList<>();
        
        // 添加元素
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        list.add("钱七");
        
        // 输出元素
        System.out.println("List 中的元素：" + list);
        
        // 获取元素
        String element = list.get(2);
        System.out.println("索引为 2 的元素：" + element);
        
        // 修改元素
        list.set(2, "王五（修改后）");
        System.out.println("修改后的 List：" + list);
        
        // 删除元素
        list.remove(2);
        System.out.println("删除索引为 2 的元素后的 List：" + list);
        
        // 遍历元素 (for 循环)
        System.out.println("遍历 List 中的元素：");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        
        // 遍历元素 (for-each 循环)
        System.out.println("遍历 List 中的元素（for-each 循环）：");
        for (String s : list) {
            System.out.println(s);
        }
    }
}

输出结果：

List 中的元素：[张三，李四，王五，赵六，钱七]
索引为 2 的元素：王五
修改后的 List：[张三，李四，王五（修改后），赵六，钱七]
删除索引为 2 的元素后的 List：[张三，李四，赵六，钱七]
遍历 List 中的元素：
张三
李四
赵六
钱七
遍历 List 中的元素（for-each 循环）：
张三
李四
赵六
钱七

结论：LinkedList 是基于双向链表的 List 实现类，查询效率低，插入和删除效率高，线程不安全。

7.4 Set 集合的常用实现类

Set 集合是无序集合，不允许重复元素。

7.4.1 HashSet 的定义与使用

定义：HashSet 是基于哈希表的 Set 实现类。

特点：

无序。
不允许重复元素。
线程不安全。

示例：

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

public class HashSetExample {
    public static void main(String[] args) {
        // 创建 HashSet 对象
        Set<String> set = new HashSet<>();
        
        // 添加元素
        set.add("张三");
        set.add("李四");
        set.add("王五");
        set.add("赵六");
        set.add("钱七");
        
        // 输出元素
        System.out.println("Set 中的元素：" + set);
        
        // 尝试添加重复元素
        set.add("张三");
        System.out.println("添加重复元素后的 Set：" + set);
        
        // 删除元素
        set.remove("王五");
        System.out.println("删除元素后的 Set：" + set);
        
        // 遍历元素
        System.out.println("遍历 Set 中的元素：");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

输出结果：

Set 中的元素：[张三，李四，王五，赵六，钱七]
添加重复元素后的 Set：[张三，李四，王五，赵六，钱七]
删除元素后的 Set：[张三，李四，赵六，钱七]
遍历 Set 中的元素：
张三
李四
赵六
钱七

结论：HashSet 是基于哈希表的 Set 实现类，无序，不允许重复元素，线程不安全。

7.4.2 LinkedHashSet 的定义与使用

定义：LinkedHashSet 是基于哈希表和链表的 Set 实现类。

特点：

有序（插入顺序）。
不允许重复元素。
线程不安全。

示例：

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetExample {
    public static void main(String[] args) {
        // 创建 LinkedHashSet 对象
        Set<String> set = new LinkedHashSet<>();
        
        // 添加元素
        set.add("张三");
        set.add("李四");
        set.add("王五");
        set.add("赵六");
        set.add("钱七");
        
        // 输出元素
        System.out.println("Set 中的元素：" + set);
        
        // 尝试添加重复元素
        set.add("张三");
        System.out.println("添加重复元素后的 Set：" + set);
        
        // 删除元素
        set.remove("王五");
        System.out.println("删除元素后的 Set：" + set);
        
        // 遍历元素
        System.out.println("遍历 Set 中的元素：");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

输出结果：

Set 中的元素：[张三，李四，王五，赵六，钱七]
添加重复元素后的 Set：[张三，李四，王五，赵六，钱七]
删除元素后的 Set：[张三，李四，赵六，钱七]
遍历 Set 中的元素：
张三
李四
赵六
钱七

结论：LinkedHashSet 是基于哈希表和链表的 Set 实现类，有序（插入顺序），不允许重复元素，线程不安全。

7.4.3 TreeSet 的定义与使用

定义：TreeSet 是基于红黑树的 Set 实现类。

特点：

有序（自然顺序）。
不允许重复元素。
线程不安全。

示例：

import java.util.TreeSet;
import java.util.Set;

public class TreeSetExample {
    public static void main(String[] args) {
        // 创建 TreeSet 对象
        Set<String> set = new TreeSet<>();
        
        // 添加元素
        set.add("张三");
        set.add("李四");
        set.add("王五");
        set.add("赵六");
        set.add("钱七");
        
        // 输出元素
        System.out.println("Set 中的元素：" + set);
        
        // 尝试添加重复元素
        set.add("张三");
        System.out.println("添加重复元素后的 Set：" + set);
        
        // 删除元素
        set.remove("王五");
        System.out.println("删除元素后的 Set：" + set);
        
        // 遍历元素
        System.out.println("遍历 Set 中的元素：");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

输出结果：

Set 中的元素：[张三，李四，王五，赵六，钱七]
添加重复元素后的 Set：[张三，李四，王五，赵六，钱七]
删除元素后的 Set：[张三，李四，赵六，钱七]
遍历 Set 中的元素：
张三
李四
赵六
钱七

结论：TreeSet 是基于红黑树的 Set 实现类，有序（自然顺序），不允许重复元素，线程不安全。

7.5 Map 集合的常用实现类

Map 集合是键值对集合，键不允许重复，值允许重复。

7.5.1 HashMap 的定义与使用

定义：HashMap 是基于哈希表的 Map 实现类。

特点：

无序。
键不允许重复，值允许重复。
线程不安全。

示例：

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

public class HashMapExample {
    public static void main(String[] args) {
        // 创建 HashMap 对象
        Map<String, Integer> map = new HashMap<>();
        
        // 添加键值对
        map.put("张三", 85);
        map.put("李四", 90);
        map.put("王五", 95);
        map.put("赵六", 80);
        map.put("钱七", 75);
        
        // 输出键值对
        System.out.println("Map 中的键值对：" + map);
        
        // 获取值
        int score = map.get("李四");
        System.out.println("李四的成绩：" + score);
        
        // 修改值
        map.put("李四", 92);
        System.out.println("修改后的 Map：" + map);
        
        // 删除键值对
        map.remove("王五");
        System.out.println("删除王五的成绩后的 Map：" + map);
        
        // 遍历键值对
        System.out.println("遍历 Map 中的键值对：");
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "的成绩：" + entry.getValue());
        }
        
        // 遍历键
        System.out.println("遍历 Map 中的键：");
         (String key : map.keySet()) {
            System.out.println(key);
        }
        
        
        System.out.println();
         ( value : map.values()) {
            System.out.println(value);
        }
    }
}

输出结果：

Map 中的键值对：{张三=85, 李四=90, 王五=95, 赵六=80, 钱七=75}
李四的成绩：90
修改后的 Map：{张三=85, 李四=92, 王五=95, 赵六=80, 钱七=75}
删除王五的成绩后的 Map：{张三=85, 李四=92, 赵六=80, 钱七=75}
遍历 Map 中的键值对：
张三的成绩：85
李四的成绩：92
赵六的成绩：80
钱七的成绩：75
遍历 Map 中的键：
张三
李四
赵六
钱七
遍历 Map 中的值：
85
92
80
75

结论：HashMap 是基于哈希表的 Map 实现类，无序，键不允许重复，值允许重复，线程不安全。

7.5.2 LinkedHashMap 的定义与使用

定义：LinkedHashMap 是基于哈希表和链表的 Map 实现类。

特点：

有序（插入顺序）。
键不允许重复，值允许重复。
线程不安全。

示例：

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        // 创建 LinkedHashMap 对象
        Map<String, Integer> map = new LinkedHashMap<>();
        
        // 添加键值对
        map.put("张三", 85);
        map.put("李四", 90);
        map.put("王五", 95);
        map.put("赵六", 80);
        map.put("钱七", 75);
        
        // 输出键值对
        System.out.println("Map 中的键值对：" + map);
        
        // 获取值
        int score = map.get("李四");
        System.out.println("李四的成绩：" + score);
        
        // 修改值
        map.put("李四", 92);
        System.out.println("修改后的 Map：" + map);
        
        // 删除键值对
        map.remove("王五");
        System.out.println("删除王五的成绩后的 Map：" + map);
        
        // 遍历键值对
        System.out.println("遍历 Map 中的键值对：");
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "的成绩：" + entry.getValue());
        }
        
        // 遍历键
        System.out.println("遍历 Map 中的键：");
         (String key : map.keySet()) {
            System.out.println(key);
        }
        
        
        System.out.println();
         ( value : map.values()) {
            System.out.println(value);
        }
    }
}

输出结果：

Map 中的键值对：{张三=85, 李四=90, 王五=95, 赵六=80, 钱七=75}
李四的成绩：90
修改后的 Map：{张三=85, 李四=92, 王五=95, 赵六=80, 钱七=75}
删除王五的成绩后的 Map：{张三=85, 李四=92, 赵六=80, 钱七=75}
遍历 Map 中的键值对：
张三的成绩：85
李四的成绩：92
赵六的成绩：80
钱七的成绩：75
遍历 Map 中的键：
张三
李四
赵六
钱七
遍历 Map 中的值：
85
92
80
75

结论：LinkedHashMap 是基于哈希表和链表的 Map 实现类，有序（插入顺序），键不允许重复，值允许重复，线程不安全。

7.5.3 TreeMap 的定义与使用

定义：TreeMap 是基于红黑树的 Map 实现类。

特点：

有序（自然顺序）。
键不允许重复，值允许重复。
线程不安全。

示例：

import java.util.TreeMap;
import java.util.Map;

public class TreeMapExample {
    public static void main(String[] args) {
        // 创建 TreeMap 对象
        Map<String, Integer> map = new TreeMap<>();
        
        // 添加键值对
        map.put("张三", 85);
        map.put("李四", 90);
        map.put("王五", 95);
        map.put("赵六", 80);
        map.put("钱七", 75);
        
        // 输出键值对
        System.out.println("Map 中的键值对：" + map);
        
        // 获取值
        int score = map.get("李四");
        System.out.println("李四的成绩：" + score);
        
        // 修改值
        map.put("李四", 92);
        System.out.println("修改后的 Map：" + map);
        
        // 删除键值对
        map.remove("王五");
        System.out.println("删除王五的成绩后的 Map：" + map);
        
        // 遍历键值对
        System.out.println("遍历 Map 中的键值对：");
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "的成绩：" + entry.getValue());
        }
        
        // 遍历键
        System.out.println("遍历 Map 中的键：");
         (String key : map.keySet()) {
            System.out.println(key);
        }
        
        
        System.out.println();
         ( value : map.values()) {
            System.out.println(value);
        }
    }
}

输出结果：

Map 中的键值对：{张三=85, 李四=90, 王五=95, 赵六=80, 钱七=75}
李四的成绩：90
修改后的 Map：{张三=85, 李四=92, 王五=95, 赵六=80, 钱七=75}
删除王五的成绩后的 Map：{张三=85, 李四=92, 赵六=80, 钱七=75}
遍历 Map 中的键值对：
张三的成绩：85
李四的成绩：92
赵六的成绩：80
钱七的成绩：75
遍历 Map 中的键：
张三
李四
赵六
钱七
遍历 Map 中的值：
85
92
80
75

结论：TreeMap 是基于红黑树的 Map 实现类，有序（自然顺序），键不允许重复，值允许重复，线程不安全。

7.6 集合的遍历方法

集合的遍历方法包括迭代器、for 循环、for-each 循环。

7.6.1 迭代器的定义与使用

定义：迭代器是一种用于遍历集合的工具。

语法：

Iterator<类型> iterator = 集合对象.iterator();
while(iterator.hasNext()){
    类型元素 = iterator.next();
    // 操作元素
}

示例：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorExample {
    public static void main(String[] args) {
        // 创建 ArrayList 对象
        List<String> list = new ArrayList<>();
        
        // 添加元素
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        list.add("钱七");
        
        // 迭代器遍历
        System.out.println("迭代器遍历 List：");
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            String s = iterator.next();
            System.out.println(s);
        }
    }
}

输出结果：

迭代器遍历 List：
张三
李四
王五
赵六
钱七

结论：迭代器是一种用于遍历集合的工具，支持删除元素操作。

7.7 实际开发中的应用场景

在实际开发中，集合的应用场景非常广泛，如：

存储用户信息。
存储商品信息。
存储订单信息。
存储日志信息。

示例：

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;

// 订单类
class Order {
    private String orderId;
    private String productId;
    private int quantity;
    private double price;

    public Order(String orderId, String productId, int quantity, double price) {
        this.orderId = orderId;
        this.productId = productId;
        this.quantity = quantity;
        this.price = price;
    }

    public String getOrderId() { return orderId; }
    public String getProductId() { return productId; }
    public int getQuantity() { return quantity; }
    public double getPrice() { return price; }
}

// 产品类
class Product {
    private String productId;
    private String productName;
    private double price;

    public Product(String productId, String productName,  price) {
        .productId = productId;
        .productName = productName;
        .price = price;
    }

     String  {  productId; }
     String  {  productName; }
       {  price; }
}


   {
        {
        
        List<Product> products =  <>();
        products.add( (, , ));
        products.add( (, , ));
        products.add( (, , ));

        
        List<Order> orders =  <>();
        orders.add( (, , , ));
        orders.add( (, , , ));
        orders.add( (, , , ));

        
        Map<String, Product> productMap =  <>();
         (Product product : products) {
            productMap.put(product.getProductId(), product);
        }

        
        System.out.println();
         (Order order : orders) {
               productMap.get(order.getProductId());
            System.out.println( + order.getOrderId());
            System.out.println( + product.getProductName());
            System.out.println( + order.getQuantity());
            System.out.println( + product.getPrice());
            System.out.println( + order.getPrice());
            System.out.println();
        }
    }
}

输出结果：

订单信息：
订单 ID：O001
产品名称：手机
数量：2
单价：1000.0
总价：2000.0
------------------------
订单 ID：O002
产品名称：电脑
数量：1
单价：2000.0
总价：2000.0
------------------------
订单 ID：O003
产品名称：平板
数量：3
单价：1500.0
总价：4500.0
------------------------

结论：在实际开发中，集合的应用场景非常广泛，需要根据实际问题选择合适的集合类型。

总结

本章我们学习了 Java 集合框架的核心组件与使用场景，包括 List、Set、Map 三种主要集合类型，了解其底层数据结构和性能特点，学会了在实际开发中根据需求选择合适的集合。其中，List 集合的常用实现类（ArrayList、LinkedList）对比、Set 集合的常用实现类（HashSet、LinkedHashSet、TreeSet）对比、Map 集合的常用实现类（HashMap、LinkedHashMap、TreeMap）对比、集合的遍历方法（迭代器、for 循环、for-each 循环）、集合的常用操作（添加、删除、修改、查找）是本章的重点内容。从下一章开始，我们将学习 Java 的异常处理、输入输出等内容。

Java 集合框架核心组件与使用场景