Java集合框架详解#

什么是集合框架？#

集合框架是Java提供的一组用于存储和操作对象的接口和类，它提供了统一的方式来管理和操作数据集合。

集合框架的层次结构#

Java集合框架主要包含以下接口：

1. Collection接口#

Collection是所有集合的根接口，它定义了集合的基本操作。

List：有序集合，允许重复元素
Set：无序集合，不允许重复元素
Queue：队列，先进先出

2. Map接口#

Map接口用于存储键值对映射，它不直接继承自Collection接口。

HashMap：基于哈希表实现，无序
LinkedHashMap：基于哈希表和链表实现，有序（插入顺序）
TreeMap：基于红黑树实现，有序（自然顺序或比较器顺序）
Hashtable：线程安全的HashMap，效率较低

List接口#

List接口是有序集合，允许重复元素，它提供了根据索引访问元素的方法。

List的实现类#

1. ArrayList#

底层实现：基于动态数组
特点：查询快，增删慢
适用场景：查询操作频繁的场景

2. LinkedList#

底层实现：基于双向链表
特点：查询慢，增删快
适用场景：增删操作频繁的场景

3. Vector#

底层实现：基于动态数组
特点：线程安全，效率较低
适用场景：多线程环境

List的常用方法#

1
List<String> list = new ArrayList<>();
2

3
// 添加元素
4
list.add("元素1"); // 添加到末尾
5
list.add(1, "元素2"); // 添加到指定位置
6

7
// 获取元素
8
String element = list.get(0);
9

10
// 修改元素
11
list.set(0, "新元素1");
12

13
// 删除元素
14
list.remove(0); // 根据索引删除
15
list.remove("元素2"); // 根据元素删除
16

17
// 查找元素
18
int index = list.indexOf("元素1"); // 查找元素的索引
19
boolean contains = list.contains("元素1"); // 检查元素是否存在
20

21
// 其他方法
22
int size = list.size(); // 获取集合大小
23
boolean isEmpty = list.isEmpty(); // 检查集合是否为空
24
list.clear(); // 清空集合
25
Object[] array = list.toArray(); // 转换为数组

List的遍历方式#

1. 普通for循环#

1
for (int i = 0; i < list.size(); i++) {
2
    System.out.println(list.get(i));
3
}

2. 增强型for循环#

1
for (String element : list) {
2
    System.out.println(element);
3
}

3. 迭代器#

1
Iterator<String> iterator = list.iterator();
2
while (iterator.hasNext()) {
3
    String element = iterator.next();
4
    System.out.println(element);
5
}

4. ListIterator#

1
ListIterator<String> listIterator = list.listIterator();
2
while (listIterator.hasNext()) {
3
    String element = listIterator.next();
4
    System.out.println(element);
5
}
6

7
// 反向遍历
8
while (listIterator.hasPrevious()) {
9
    String element = listIterator.previous();
10
    System.out.println(element);
11
}

Set接口#

Set接口是无序集合，不允许重复元素，它继承自Collection接口。

Set的实现类#

1. HashSet#

底层实现：基于哈希表
特点：无序，不允许重复元素，查询速度快
适用场景：需要快速查找且不关心顺序的场景

2. LinkedHashSet#

底层实现：基于哈希表和链表
特点：有序（插入顺序），不允许重复元素
适用场景：需要保持插入顺序的场景

3. TreeSet#

底层实现：基于红黑树
特点：有序（自然顺序或比较器顺序），不允许重复元素
适用场景：需要排序的场景

Set的常用方法#

1
Set<String> set = new HashSet<>();
2

3
// 添加元素
4
set.add("元素1");
5
set.add("元素2");
6
set.add("元素1"); // 重复元素，不会添加
7

8
// 删除元素
9
set.remove("元素1");
10

11
// 查找元素
12
boolean contains = set.contains("元素1");
13

14
// 其他方法
15
int size = set.size();
16
boolean isEmpty = set.isEmpty();
17
set.clear();
18
Object[] array = set.toArray();

Set的遍历方式#

1. 增强型for循环#

1
for (String element : set) {
2
    System.out.println(element);
3
}

2. 迭代器#

1
Iterator<String> iterator = set.iterator();
2
while (iterator.hasNext()) {
3
    String element = iterator.next();
4
    System.out.println(element);
5
}

Map接口#

Map接口用于存储键值对映射，它提供了根据键访问值的方法。

Map的实现类#

1. HashMap#

底层实现：基于哈希表
特点：无序，键不允许重复
适用场景：需要快速查找的场景

2. LinkedHashMap#

底层实现：基于哈希表和链表
特点：有序（插入顺序），键不允许重复
适用场景：需要保持插入顺序的场景

3. TreeMap#

底层实现：基于红黑树
特点：有序（自然顺序或比较器顺序），键不允许重复
适用场景：需要排序的场景

4. Hashtable#

底层实现：基于哈希表
特点：线程安全，效率较低，键不允许重复
适用场景：多线程环境

Map的常用方法#

1
Map<String, Integer> map = new HashMap<>();
2

3
// 添加元素
4
map.put("键1", 1);
5
map.put("键2", 2);
6

7
// 获取元素
8
Integer value = map.get("键1");
9

10
// 修改元素
11
map.put("键1", 10); // 覆盖原有值
12

13
// 删除元素
14
map.remove("键1");
15

16
// 查找元素
17
boolean containsKey = map.containsKey("键1"); // 检查键是否存在
18
boolean containsValue = map.containsValue(1); // 检查值是否存在
19

20
// 其他方法
21
int size = map.size();
22
boolean isEmpty = map.isEmpty();
23
map.clear();
24

25
// 获取所有键
26
Set<String> keys = map.keySet();
27

28
// 获取所有值
29
Collection<Integer> values = map.values();
30

31
// 获取所有键值对
32
Set<Map.Entry<String, Integer>> entries = map.entrySet();

Map的遍历方式#

1. 遍历键#

1
for (String key : map.keySet()) {
2
    Integer value = map.get(key);
3
    System.out.println(key + ": " + value);
4
}

2. 遍历键值对#

1
for (Map.Entry<String, Integer> entry : map.entrySet()) {
2
    String key = entry.getKey();
3
    Integer value = entry.getValue();
4
    System.out.println(key + ": " + value);
5
}

3. 遍历值#

1
for (Integer value : map.values()) {
2
    System.out.println(value);
3
}

队列和栈#

Queue接口#

Queue接口是队列，它提供了先进先出（FIFO）的操作方式。

Queue的实现类#

LinkedList：实现了Queue接口
PriorityQueue：优先级队列，基于堆实现

Queue的常用方法#

1
Queue<String> queue = new LinkedList<>();
2

3
// 添加元素
4
queue.offer("元素1"); // 添加失败返回false
5
queue.add("元素2"); // 添加失败抛出异常
6

7
// 获取并移除队首元素
8
String element = queue.poll(); // 队列为空返回null
9
String element = queue.remove(); // 队列为空抛出异常
10

11
// 获取队首元素但不移除
12
String element = queue.peek(); // 队列为空返回null
13
String element = queue.element(); // 队列为空抛出异常

Stack类#

Stack类是栈，它提供了后进先出（LIFO）的操作方式。

Stack的常用方法#

1
Stack<String> stack = new Stack<>();
2

3
// 压栈
4
stack.push("元素1");
5
stack.push("元素2");
6

7
// 出栈
8
String element = stack.pop(); // 栈为空抛出异常
9

10
// 查看栈顶元素
11
String element = stack.peek(); // 栈为空抛出异常
12

13
// 检查栈是否为空
14
boolean isEmpty = stack.isEmpty();
15

16
// 获取栈大小
17
int size = stack.size();

并发集合#

Java提供了线程安全的并发集合，它们位于java.util.concurrent包中。

并发集合的实现类#

1. ConcurrentHashMap#

特点：线程安全的HashMap，支持高并发读写
适用场景：多线程环境下的哈希表操作

2. CopyOnWriteArrayList#

特点：线程安全的ArrayList，适用于读多写少的场景
适用场景：多线程环境下的读操作频繁的场景

3. CopyOnWriteArraySet#

特点：基于CopyOnWriteArrayList实现，线程安全的Set
适用场景：多线程环境下的读操作频繁的场景

4. ConcurrentLinkedQueue#

特点：线程安全的无界队列
适用场景：多线程环境下的队列操作

5. BlockingQueue#

特点：阻塞队列，支持线程安全的入队和出队操作
实现类：ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue等
适用场景：多线程环境下的生产者-消费者模式

集合工具类#

Collections类#

Collections类提供了操作集合的静态方法。

Collections的常用方法#

1
// 排序
2
Collections.sort(list); // 自然排序
3
Collections.sort(list, comparator); // 自定义排序
4

5
// 查找
6
int index = Collections.binarySearch(list, key); // 二分查找
7
Object max = Collections.max(collection); // 最大值
8
Object min = Collections.min(collection); // 最小值
9

10
// 填充
11
Collections.fill(list, value); // 填充所有元素
12

13
// 拷贝
14
Collections.copy(dest, src); // 拷贝集合
15

16
// 反转
17
Collections.reverse(list); // 反转集合
18

19
// 随机打乱
20
Collections.shuffle(list); // 随机打乱集合
21

22
// 替换
23
Collections.replaceAll(list, oldValue, newValue); // 替换所有元素
24

25
// 线程安全
26
List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());
27
Set<String> synchronizedSet = Collections.synchronizedSet(new HashSet<>());
28
Map<String, Integer> synchronizedMap = Collections.synchronizedMap(new HashMap<>());

Arrays类#

Arrays类提供了操作数组的静态方法，它也可以用于数组和集合的转换。

Arrays的常用方法#

1
// 数组转集合
2
List<String> list = Arrays.asList(array);
3

4
// 集合转数组
5
String[] array = list.toArray(new String[0]);
6

7
// 排序
8
Arrays.sort(array); // 自然排序
9
Arrays.sort(array, comparator); // 自定义排序
10

11
// 查找
12
int index = Arrays.binarySearch(array, key); // 二分查找
13

14
// 填充
15
Arrays.fill(array, value); // 填充所有元素
16

17
// 比较
18
boolean equals = Arrays.equals(array1, array2); // 比较两个数组
19

20
// 哈希码
21
int hashCode = Arrays.hashCode(array); // 获取数组的哈希码
22

23
// 字符串表示
24
String str = Arrays.toString(array); // 获取数组的字符串表示

集合的最佳实践#

1. 选择合适的集合#

需要有序、可重复的元素：使用List
- 查询频繁：ArrayList
- 增删频繁：LinkedList
- 多线程环境：Vector
需要无序、不可重复的元素：使用Set
- 不需要排序：HashSet
- 需要保持插入顺序：LinkedHashSet
- 需要排序：TreeSet
需要键值对映射：使用Map
- 不需要排序：HashMap
- 需要保持插入顺序：LinkedHashMap
- 需要排序：TreeMap
- 多线程环境：Hashtable或ConcurrentHashMap

2. 初始化时指定容量#

对于已知大小的集合，初始化时指定容量可以提高性能。

1
// 好的做法
2
List<String> list = new ArrayList<>(100); // 指定初始容量
3
Map<String, Integer> map = new HashMap<>(100); // 指定初始容量

3. 使用泛型#

使用泛型可以避免类型转换错误，提高代码安全性。

1
// 好的做法
2
List<String> list = new ArrayList<>();
3
String element = list.get(0); // 不需要类型转换
4

5
// 坏的做法
6
List list = new ArrayList();
7
String element = (String) list.get(0); // 需要类型转换，可能出错

4. 优先使用增强型for循环#

遍历集合时，优先使用增强型for循环，代码更简洁。

1
// 好的做法
2
for (String element : list) {
3
    System.out.println(element);
4
}
5

6
// 坏的做法
7
for (int i = 0; i < list.size(); i++) {
8
    System.out.println(list.get(i));
9
}

5. 避免在循环中修改集合#

在遍历集合时修改集合，可能会导致ConcurrentModificationException异常。

1
// 坏的做法
2
for (String element : list) {
3
    if (element.equals("删除元素")) {
4
        list.remove(element); // 可能抛出ConcurrentModificationException
5
    }
6
}
7

8
// 好的做法
9
Iterator<String> iterator = list.iterator();
10
while (iterator.hasNext()) {
11
    String element = iterator.next();
12
    if (element.equals("删除元素")) {
13
        iterator.remove(); // 正确的删除方式
14
    }
15
}

6. 使用集合的isEmpty()方法#

检查集合是否为空时，使用isEmpty()方法而不是size() == 0，代码更简洁，可读性更好。

1
// 好的做法
2
if (list.isEmpty()) {
3
    System.out.println("集合为空");
4
}
5

6
// 坏的做法
7
if (list.size() == 0) {
8
    System.out.println("集合为空");
9
}

7. 合理使用并发集合#

在多线程环境下，使用线程安全的并发集合，而不是手动同步。

1
// 好的做法
2
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
3

4
// 坏的做法
5
Map<String, Integer> map = Collections.synchronizedMap(new HashMap<>());

8. 注意集合的线程安全性#

大多数集合类不是线程安全的，在多线程环境下需要手动同步或使用线程安全的集合。

常见陷阱#

1. Arrays.asList()的局限性#

Arrays.asList()返回的是一个固定大小的列表，不支持添加和删除操作。

1
String[] array = {"a", "b", "c"};
2
List<String> list = Arrays.asList(array);
3
list.add("d"); // 抛出UnsupportedOperationException异常

2. 集合与原始类型#

集合只能存储对象，不能存储原始类型，需要使用包装类。

1
// 错误
2
List<int> list = new ArrayList<>();
3

4
// 正确
5
List<Integer> list = new ArrayList<>();

3. ConcurrentModificationException#

在遍历集合时修改集合，可能会抛出ConcurrentModificationException异常。

4. 内存泄漏#

集合中存储的对象如果没有被正确清理，可能会导致内存泄漏。

5. 哈希码和equals方法#

使用HashSet或HashMap时，元素或键应该正确实现hashCode()和equals()方法。

1
public class Person {
2
    private String name;
3
    private int age;
4

5
    // 必须实现equals()和hashCode()方法
6
    @Override
7
    public boolean equals(Object o) {
8
        if (this == o) return true;
9
        if (o == null || getClass() != o.getClass()) return false;
10
        Person person = (Person) o;
11
        return age == person.age && Objects.equals(name, person.name);
12
    }
13

14
    @Override
15
    public int hashCode() {
16
        return Objects.hash(name, age);
17
    }
18
}

6. 集合的大小#

集合的size()方法返回的是int类型，对于非常大的集合，可能会导致溢出。

7. 自动装箱和拆箱的性能影响#

在使用集合存储包装类时，自动装箱和拆箱可能会影响性能。

总结#

Java集合框架是Java编程中的重要部分，它提供了丰富的接口和类，用于存储和操作数据集合。不同的集合类有不同的特点和适用场景，我们应该根据具体需求选择合适的集合。

本文介绍了Java集合框架的层次结构、常用集合类的特点和使用方法，以及集合的最佳实践和常见陷阱。希望本文能够帮助你更好地理解和使用Java的集合框架。

练习#

编写一个程序，使用ArrayList存储学生信息，并实现添加、删除、修改和查询操作。
编写一个程序，使用LinkedList实现一个队列。
编写一个程序，使用HashSet存储不重复的整数，并实现添加、删除和遍历操作。
编写一个程序，使用TreeSet存储字符串，并按照字典序排序。
编写一个程序，使用HashMap存储学生的姓名和成绩，并实现添加、删除、修改和查询操作。
编写一个程序，使用LinkedHashMap存储元素，并验证它保持插入顺序。
编写一个程序，使用TreeMap存储键值对，并按照键的自然顺序排序。
编写一个程序，使用Collections工具类对List进行排序、查找和反转操作。
编写一个程序，使用并发集合（如ConcurrentHashMap）在多线程环境下操作数据。
编写一个程序，使用BlockingQueue实现生产者-消费者模式。

溪谷回声

投石问路，静听回响

Java集合框架详解