Java 集合框架
Java 集合框架（Collections Framework）提供了用于存储和操作对象组的类和接口。
集合框架概述
集合框架层次结构
Collection（接口）
├── List（接口）- 有序、可重复
│ ├── ArrayList
│ ├── LinkedList
│ └── Vector
├── Set（接口）- 无序、不可重复
│ ├── HashSet
│ ├── LinkedHashSet
│ └── TreeSet
└── Queue（接口）- 队列
├── LinkedList
└── PriorityQueue
Map（接口）- 键值对
├── HashMap
├── LinkedHashMap
├── TreeMap
└── Hashtable
List 集合
ArrayList
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(1, "葡萄"); // 在指定位置插入
// 获取元素
String fruit = list.get(0); // "苹果"
System.out.println("第一个元素：" + fruit);
// 获取大小
int size = list.size(); // 4
System.out.println("列表大小：" + size);
// 遍历
for (String item : list) {
System.out.println(item);
}
// 检查是否包含
boolean contains = list.contains("苹果"); // true
// 删除元素
list.remove("香蕉");
list.remove(0); // 删除索引为 0 的元素
// 清空
list.clear();
}
}LinkedList
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("A");
list.add("B");
list.add("C");
// LinkedList 特有的方法
LinkedList<String> linkedList = (LinkedList<String>) list;
linkedList.addFirst("开始"); // 在开头添加
linkedList.addLast("结束"); // 在末尾添加
linkedList.removeFirst(); // 删除第一个
linkedList.removeLast(); // 删除最后一个
}
}Set 集合
HashSet
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("苹果"); // 重复元素，不会添加
System.out.println("集合大小：" + set.size()); // 2
// 遍历（顺序不确定）
for (String item : set) {
System.out.println(item);
}
// 检查是否包含
boolean contains = set.contains("苹果"); // true
// 删除
set.remove("香蕉");
}
}TreeSet
import java.util.TreeSet;
import java.util.Set;
public class TreeSetExample {
public static void main(String[] args) {
// TreeSet 有序、不重复（按自然顺序或自定义顺序）
Set<Integer> set = new TreeSet<>();
set.add(5);
set.add(2);
set.add(8);
set.add(1);
// 遍历（有序）
for (Integer num : set) {
System.out.println(num); // 输出：1, 2, 5, 8（有序）
}
}
}Map 集合
HashMap
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("苹果", 10);
map.put("香蕉", 20);
map.put("橙子", 15);
// 获取值
Integer count = map.get("苹果"); // 10
System.out.println("苹果数量：" + count);
// 检查键是否存在
boolean containsKey = map.containsKey("苹果"); // true
boolean containsValue = map.containsValue(10); // true
// 获取所有键
for (String key : map.keySet()) {
System.out.println(key + ": " + map.get(key));
}
// 获取所有值
for (Integer value : map.values()) {
System.out.println(value);
}
// 获取所有键值对
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
// 删除
map.remove("苹果");
// 大小
int size = map.size(); // 2
}
}TreeMap
import java.util.TreeMap;
import java.util.Map;
public class TreeMapExample {
public static void main(String[] args) {
// TreeMap 有序的 Map（按键排序）
Map<String, Integer> map = new TreeMap<>();
map.put("香蕉", 20);
map.put("苹果", 10);
map.put("橙子", 15);
// 遍历（按键排序）
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
// 输出：
// 苹果: 10
// 橙子: 15
// 香蕉: 20
}
}集合操作
集合遍历
import java.util.*;
public class CollectionIteration {
public static void main(String[] args) {
List<String> list = Arrays.asList("A", "B", "C");
// 方式1：for-each 循环
for (String item : list) {
System.out.println(item);
}
// 方式2：迭代器
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String item = iterator.next();
System.out.println(item);
}
// 方式3：Java 8+ Stream API
list.forEach(item -> System.out.println(item));
list.forEach(System.out::println); // 方法引用
}
}集合转换
import java.util.*;
public class CollectionConversion {
public static void main(String[] args) {
// List 转 Set（去重）
List<String> list = Arrays.asList("A", "B", "A", "C");
Set<String> set = new HashSet<>(list);
System.out.println(set); // [A, B, C]
// Set 转 List
List<String> newList = new ArrayList<>(set);
// 数组转 List
String[] array = {"A", "B", "C"};
List<String> listFromArray = Arrays.asList(array);
// List 转数组
String[] arrayFromList = list.toArray(new String[0]);
}
}实际应用示例
示例1：学生成绩管理
import java.util.*;
public class StudentGradeManager {
// 使用 Map 存储学生成绩
private Map<String, List<Integer>> grades = new HashMap<>();
public void addGrade(String studentName, int grade) {
grades.putIfAbsent(studentName, new ArrayList<>());
grades.get(studentName).add(grade);
}
public double getAverage(String studentName) {
List<Integer> studentGrades = grades.get(studentName);
if (studentGrades == null || studentGrades.isEmpty()) {
return 0.0;
}
int sum = 0;
for (int grade : studentGrades) {
sum += grade;
}
return (double) sum / studentGrades.size();
}
public void displayAll() {
for (Map.Entry<String, List<Integer>> entry : grades.entrySet()) {
String name = entry.getKey();
double avg = getAverage(name);
System.out.println(name + " 的平均分：" + avg);
}
}
}示例2：去重统计
import java.util.*;
public class Deduplication {
public static void main(String[] args) {
// 统计不重复的元素
List<String> list = Arrays.asList("苹果", "香蕉", "苹果", "橙子", "香蕉");
// 使用 Set 去重
Set<String> uniqueItems = new HashSet<>(list);
System.out.println("不重复的元素：" + uniqueItems);
System.out.println("数量：" + uniqueItems.size());
// 统计每个元素出现的次数
Map<String, Integer> countMap = new HashMap<>();
for (String item : list) {
countMap.put(item, countMap.getOrDefault(item, 0) + 1);
}
for (Map.Entry<String, Integer> entry : countMap.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue() + " 次");
}
}
}总结
Java 集合框架提供了丰富的数据结构：
- List：有序、可重复（ArrayList、LinkedList）
- Set：无序、不可重复（HashSet、TreeSet）
- Map：键值对（HashMap、TreeMap）
- 选择原则：
- 需要有序、可重复：使用 List
- 需要去重：使用 Set
- 需要键值对：使用 Map
- 需要频繁插入删除：使用 LinkedList
- 需要排序：使用 TreeSet 或 TreeMap
掌握集合框架是 Java 开发的基础。
相关链接：