Java 集合框架核心组件与使用场景
Java 集合框架包含 List、Set、Map 三大类。List 有序可重复,常用 ArrayList(数组)和 LinkedList(链表)。Set 无序不可重复,常用 HashSet、LinkedHashSet、TreeSet。Map 键值对存储,常用 HashMap、LinkedHashMap、TreeMap。掌握各实现类的底层结构、性能特点及遍历方式,有助于在实际开发中根据需求选择合适集合。

Java 集合框架包含 List、Set、Map 三大类。List 有序可重复,常用 ArrayList(数组)和 LinkedList(链表)。Set 无序不可重复,常用 HashSet、LinkedHashSet、TreeSet。Map 键值对存储,常用 HashMap、LinkedHashMap、TreeMap。掌握各实现类的底层结构、性能特点及遍历方式,有助于在实际开发中根据需求选择合适集合。

学习目标:掌握 Java 集合框架的核心组件,包括 List、Set、Map 三种主要集合类型,了解其底层数据结构和性能特点,学会在实际开发中根据需求选择合适的集合。
重点:
Java 集合框架是一个用于存储和操作对象的体系结构,提供了多种集合类型和算法。
定义:集合框架分为三大类:
结论:集合框架分为三大类:List、Set、Map。
定义:集合框架的核心接口包括:
结论:集合框架的核心接口包括 Collection、List、Set、Map。
List 集合是有序集合,允许重复元素。
定义: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 实现类,查询效率高,插入和删除效率低,线程不安全。
定义: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 实现类,查询效率低,插入和删除效率高,线程不安全。
Set 集合是无序集合,不允许重复元素。
定义: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 实现类,无序,不允许重复元素,线程不安全。
定义: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 实现类,有序(插入顺序),不允许重复元素,线程不安全。
定义: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 实现类,有序(自然顺序),不允许重复元素,线程不安全。
Map 集合是键值对集合,键不允许重复,值允许重复。
定义: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 实现类,无序,键不允许重复,值允许重复,线程不安全。
定义: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 实现类,有序(插入顺序),键不允许重复,值允许重复,线程不安全。
定义: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 实现类,有序(自然顺序),键不允许重复,值允许重复,线程不安全。
集合的遍历方法包括迭代器、for 循环、for-each 循环。
定义:迭代器是一种用于遍历集合的工具。
语法:
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:
张三
李四
王五
赵六
钱七
结论:迭代器是一种用于遍历集合的工具,支持删除元素操作。
在实际开发中,集合的应用场景非常广泛,如:
示例:
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 的异常处理、输入输出等内容。

微信公众号「极客日志」,在微信中扫描左侧二维码关注。展示文案:极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具,Keycode 信息在线工具,online
JavaScript 字符串转义/反转义;Java 风格 \uXXXX(Native2Ascii)编码与解码。 在线工具,Escape 与 Native 编解码在线工具,online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具,JavaScript / HTML 格式化在线工具,online
Terser 压缩、变量名混淆,或 javascript-obfuscator 高强度混淆(体积会增大)。 在线工具,JavaScript 压缩与混淆在线工具,online
使用加密算法(如AES、TripleDES、Rabbit或RC4)加密和解密文本明文。 在线工具,加密/解密文本在线工具,online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具,Base64 字符串编码/解码在线工具,online