【Java 基础】17 集合

news2025/1/15 13:20:29

文章目录

- 1.基本概念
- 2.核心接口
- 3.常见实现
- - 1）List 接口的实现类
  - - ArrayList
    - LinkedList
    - Vector
  - 2）Set 接口的实现类
  - - HashSet
    - LinkedHashSet
    - TreeSet
  - 3）Queue 接口的实现**类**
  - - ArrayQueue
  - 4）Map 接口的实现类
  - - HashMap
    - LinkedHashMap
    - TreeMap
- 4.最佳实践

集合框架（Collection Framework）是一组 用于存储和操作数据的类和接口。它提供了一种灵活、高效的数据结构，适用于各种编程场景。

1.基本概念

集合就是把分散的 “东西” 聚集到一起。

集合框架就是为集合提供了一套通用的操作方式供使用。

Java 集合框架的设计目标是提供一组通用的、类型安全的接口和实现，使得我们能够轻松地操作和管理数据。
在这里插入图片描述

2.核心接口

在这里插入图片描述

集合框架的常用核心接口：

接口名称	功能描述	常见实现
Collection	表示一组对象，除 `Map` 外所有集合的根接口，定义了基本的集合操作，如添加、删除、遍历等	-
List	表示一个有序的集合，允许重复元素	`ArrayList`、`LinkedList` 和 `Vector`等
Set	表示一个不包含重复元素的集合	`HashSet`、`LinkedHashSet` 和 `TreeSet`等
Queue	表示一个有序的集合，是一个先进先出的队列	`ArrayDeque`等
Map	表示键值对的集合，每个键都唯一	`HashMap`、`LinkedHashMap`、`TreeMap`等

3.常见实现

1）List 接口的实现类

ArrayList

基于动态数组实现，支持快速随机访问。

public static void main(String[] args) {
	List<String> arrayList = new ArrayList<>();
	arrayList.add("b");
    arrayList.add("a");
    arrayList.add("a");
	System.out.println(arrayList);
}

输出结果：[b, a, a]

LinkedList

基于双向链表实现，适合插入和删除操作。

public static void main(String[] args) {
	List<String> linkedList = new LinkedList<>();
	linkedList.add("b");
    linkedList.add("a");
    linkedList.add("a");
	System.out.println(linkedList);
}

输出结果：[b, a, a]

Vector

类似于 ArrayList，但是是线程安全的。

public static void main(String[] args) {
	List<String> vector = new Vector<>();
	vector.add("b");
    vector.add("a");
    vector.add("a");
	System.out.println(vector);
}

输出结果：[b, a, a]

这样简单的存储操作，结果都是相同的，只不过内部的实现方式不同而已。

2）Set 接口的实现类

HashSet

基于哈希表实现，无序且不允许重复元素。

public static void main(String[] args) {
    Set<String> hashSet = new HashSet<>();
    hashSet.add("b");
    hashSet.add("a");
    hashSet.add("a");
    System.out.println(hashSet);
}

输出结果：[a, b]

LinkedHashSet

基于哈希表和链表实现，有序且不允许重复元素。

public static void main(String[] args) {
    Set<String> linkedHashSet = new LinkedHashSet<>();
    linkedHashSet.add("b");
    linkedHashSet.add("a");
    linkedHashSet.add("a");
    System.out.println(linkedHashSet);
}

输出结果：[b, a]

TreeSet

基于红黑树实现，有序且不允许重复元素（有序是指可以按照元素的大小顺序自动排序）。

public static void main(String[] args) {
    Set<String> treeSet = new TreeSet<>();
    treeSet.add("b");
    treeSet.add("a");
    treeSet.add("a");
    System.out.println(treeSet);
}

输出结果：[a, b]

3）Queue 接口的实现类

ArrayQueue

双端队列，是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。

将其用作栈

public static void main(String[] args) {
    Deque<Integer> stack = new ArrayDeque<>();
    stack.push(0);
    stack.push(1);
    stack.push(2);
    System.out.println(stack);
    System.out.println(stack.pop());
    System.out.println(stack);
}

输出结果：

[2, 1, 0]
2
[1, 0]

将其用作队列

public static void main(String[] args) {
    Deque<Integer> deque = new ArrayDeque<>();
    deque.offer(0);
    deque.offer(1);
    deque.offer(2);
    System.out.println(deque);
    System.out.println(deque.poll());
    System.out.println(deque);
}

输出结果：

[0, 1, 2]
0
[1, 2]

4）Map 接口的实现类

HashMap

基于哈希表实现，键值对无序。

public static void main(String[] args) {
    Map<String, String> hashMap = new HashMap<>();
    hashMap.put("b", "bb");
    hashMap.put("a", "aa");
    hashMap.put("a", "aa");
    System.out.println(hashMap);
}

输出结果：{a=aa, b=bb}

LinkedHashMap

基于哈希表和链表实现，键值对有序。

public static void main(String[] args) {
    Map<String, String> linkedHashMap = new LinkedHashMap<>();
    linkedHashMap.put("b", "bb");
    linkedHashMap.put("a", "aa");
    linkedHashMap.put("a", "aa");
    System.out.println(linkedHashMap);
}

输出结果：{b=bb, a=aa}

TreeMap

基于红黑树实现，键值对有序（有序是指可以按照元素的大小顺序自动排序）。

public static void main(String[] args) {
    Map<String, String> treeMap = new TreeMap<>();
    treeMap.put("b", "bb");
    treeMap.put("a", "aa");
    treeMap.put("a", "aa");
    System.out.println(treeMap);
}

输出结果：{a=aa, b=bb}

4.最佳实践

选择合适的集合类型： 根据需求选择不同的集合类型

例如：需要有序且不允许重复元素，可以选择 TreeSet 或 LinkedHashSet。
遍历集合： 使用增强型 for 循环或迭代器进行集合遍历，提高代码的可读性。
```
for (String item : list) {
    System.out.println(item);
}
```
使用泛型： 在集合中使用泛型能够提高代码的类型安全性，避免在运行时出现类型转换错误。
注意线程安全性： 根据程序的多线程需求选择合适的集合实现

例如：需要线程安全的集合可以选择 Vector 或使用 Collections.synchronizedList。

使用 stream： Java 8 引入了一些便利的集合处理方法

例如： stream()、filter()、map() 等，可以简化集合操作。

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("Test");
    list.add("Hello world");
    System.out.println("list: " + list);
    List<String> helloList = list.stream()
        .filter(s -> s.startsWith("Hello")).collect(Collectors.toList());
    System.out.println("helloList: " + helloList);
}