在这里插入图片描述

博主：_LJaXi Or 東方幻想郷
专栏： Java | 从跨行业到跨平台
开发工具：IntelliJ IDEA 2021.1.3

Java集合框架 API接口

Collection接口
List接口
HashSet， TreeSet
Set接口
- `使用 HashSet 实现`
- `使用 TreeSet 实现`
HashMap、TreeMap
Map接口
- `使用 HashMap 实现`
- `使用 TreeMap 实现`
LinkedList、PriorityQueue
Queue接口
- `使用 LinkedList 实现`
- `使用 PriorityQueue 实现`
ArrayDeque、LinkedList
Deque接口
- `使用 ArrayDeque 实现`
- `使用 LinkedList 实现`
Java 集合框架那么多接口，功能都相似，我该如何区分使用?

Java集合API提供了一组功能强大的数据结构和算法, 具有以下作用(简述)

存储和组织数据
提供高效的数据访问和操作
实现算法和数据处理
提供线程安全性
支持泛型编程

java.util.Collection是集合框架的根接口。它位于集合框架层次结构的顶部。它包含一些重要的方法，例如每个 Collection 类都必须实现的 size()、iterator()、add()、remove()、clear()
其他一些重要的接口是 java.util.List、java.util.Set、java.util.Queue、java.util.Map, Map 是唯一不继承自 Collection 接口的接口，但它是 Collections 框架的一部分。所有集合框架接口都存在于 java.util 包中

Collection接口

代表了一组对象的集合。它是其他集合接口的父接口，提供了基本的操作方法，如添加、删除、查询等。

Collection<String> collection = new ArrayList<>();// 添加元素
collection.add("元素1");
collection.add("元素2");
collection.add("元素3");// 删除元素
collection.remove("元素2");// 遍历集合
for (String item : collection) {System.out.println(item);
}

List接口

继承自 Collection 接口，表示有序的集合。List中的元素可以根据索引进行访问，可以包含重复的元素。

import java.util.ArrayList;
import java.util.List;public class ListExample {public static void main(String[] args) {List<String> list = new ArrayList<>();// 添加元素list.add("Java");list.add("Python");list.add("C++");// 获取元素String element = list.get(0);System.out.println("第一个元素：" + element);// 删除元素list.remove(1);// 遍历元素for (String str : list) {System.out.println(str);}// 判断是否包含某个元素boolean contains = list.contains("Java");System.out.println("是否包含Java：" + contains);// 清空列表list.clear();// 判断列表是否为空boolean empty = list.isEmpty();System.out.println("列表是否为空：" + empty);}
}

HashSet， TreeSet

HashSet 是 Java 集合框架中 Set 接口的实现类之一，它是一个无序、不重复的集合
TreeSet 是 Java 集合框架中 Set 接口的另一个实现类，它基于红黑树的数据结构实现，TreeSet 的作用是提供了一个有序且不重复的集合

Set接口

继承自 Collection 接口，表示不允许包含重复元素的集合。Set没有定义特定的顺序，可以使用HashSet、TreeSet等具体实现。

`使用 HashSet 实现`

import java.util.Set;
import java.util.HashSet;public class SetExample {public static void main(String[] args) {// 创建HashSet对象Set<String> set = new HashSet<>();// 添加元素set.add("Apple");set.add("Banana");set.add("Orange");set.add("Grape");// 打印集合大小System.out.println("集合大小: " + set.size());// 遍历集合for (String fruit : set) {System.out.println(fruit);}// 判断集合中是否包含指定元素String target = "Banana";if (set.contains(target)) {System.out.println("集合中包含" + target);} else {System.out.println("集合中不包含" + target);}// 删除元素set.remove("Orange");// 清空集合set.clear();// 判断集合是否为空if (set.isEmpty()) {System.out.println("集合为空");} else {System.out.println("集合不为空");}}
}

`使用 TreeSet 实现`

import java.util.Set;
import java.util.TreeSet;public class TreeSetExample {public static void main(String[] args) {Set<Integer> set = new TreeSet<>();// 添加元素set.add(5);set.add(2);set.add(8);set.add(3);set.add(1);// 遍历集合for (Integer element : set) {System.out.println(element);}// 获取集合大小int size = set.size();System.out.println("集合大小: " + size);// 判断集合中是否包含指定元素boolean contains = set.contains(3);System.out.println("集合中是否包含3: " + contains);// 删除元素set.remove(2);// 判断集合是否为空boolean isEmpty = set.isEmpty();System.out.println("集合是否为空: " + isEmpty);}
}

HashMap、TreeMap

HashMap 是基于哈希表实现的，它提供了快速的插入、删除和查找操作，时间复杂度为 O(1)
HashMap 不保证顺序，允许有 null键 和 null值，适用于大多数情况，特别是在需要快速查找键值对的场景中
O(1) 就是不需要遍历查找，直接得到搜索结果的，例如哈希表、bitmap等数据结构，都可以作为O(1) 时间复杂度算法的数据结构

TreeMap 是基于红黑树（一种自平衡二叉搜索树）实现的，它可以保持元素的有序性，TreeMap 支持高效的插入、删除和查找操作，时间复杂度为 O(logN)
O(logN) 是一种时间复杂度的表示，表示算法在最坏情况下的运行时间与输入规模 N 的对数成正比。其中，O 表示“大约”，而 logN 是以 2 为底的对数

Map接口

表示键值对的映射集合。Map中的元素以键值对的形式存储，通过键来唯一标识值。常用的实现类有HashMap、TreeMap等。

`使用 HashMap 实现`

import java.util.HashMap;
import java.util.Map;public class HashMapWithNulls {public static void main(String[] args) {// 创建一个 HashMap 实例，允许 null 键和 null 值Map<String, Integer> map = new HashMap<>();// 添加键值对，包括 null 键和 null 值map.put("key1", 100);map.put(null, 200);map.put("key3", null);// 获取键对应的值，包括 null 键和 null 值Integer value1 = map.get("key1");System.out.println("key1 对应的值: " + value1);Integer value2 = map.get(null);System.out.println("null 对应的值: " + value2);Integer value3 = map.get("key3");System.out.println("key3 对应的值: " + value3);// 遍历所有的键值对，包括 null 键和 null 值for (Map.Entry<String, Integer> entry : map.entrySet()) {String key = entry.getKey();Integer value = entry.getValue();System.out.println("键: " + key + ", 值: " + value);}// 删除特定的键值对map.remove(null);// 判断是否包含某个键boolean containsKey = map.containsKey(null);System.out.println("是否包含 null 键: " + containsKey);// 判断是否包含某个值boolean containsValue = map.containsValue(null);System.out.println("是否包含 null 值: " + containsValue);// 判断集合是否为空boolean isEmpty = map.isEmpty();System.out.println("集合是否为空: " + isEmpty);}
}

`使用 TreeMap 实现`

import java.util.Map;
import java.util.TreeMap;public class TreeMapExample {public static void main(String[] args) {// 创建一个 TreeMap 实例TreeMap<String, Integer> treeMap = new TreeMap<>();// 添加键值对treeMap.put("Alice", 95);treeMap.put("Bob", 87);treeMap.put("Charlie", 92);treeMap.put("David", 78);// 获取键对应的值int aliceScore = treeMap.get("Alice");System.out.println("Alice 的分数是：" + aliceScore);// 遍历所有的键值对for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {String name = entry.getKey();int score = entry.getValue();System.out.println(name + " 的分数是：" + score);}// 获取第一个键值对Map.Entry<String, Integer> firstEntry = treeMap.firstEntry();System.out.println("第一个键值对：" + firstEntry.getKey() + " => " + firstEntry.getValue());// 获取最后一个键值对Map.Entry<String, Integer> lastEntry = treeMap.lastEntry();System.out.println("最后一个键值对：" + lastEntry.getKey() + " => " + lastEntry.getValue());// 获取键小于等于给定键的键值对Map.Entry<String, Integer> floorEntry = treeMap.floorEntry("Charlie");System.out.println("小于等于 Charlie 的键值对：" + floorEntry.getKey() + " => " + floorEntry.getValue());// 删除键值对treeMap.remove("Charlie");// 判断集合是否为空boolean isEmpty = treeMap.isEmpty();System.out.println("集合是否为空：" + isEmpty);}
}

LinkedList、PriorityQueue

LinkedList 是 Java 集合框架中的一种实现了 List 接口的双向链表数据结构。它提供了对元素的高效插入、删除以及随机访问操作
LinkedList 主要适用于需要频繁插入、删除操作，以及在集合中间进行操作的场景，它在实现队列、链表特有操作和特定的业务需求上表现出色。但需要注意在需要随机访问元素时，可能会使用较低的性能

PriorityQueue 主要适用于需要根据优先级对元素进行排序的场景，它在任务调度、事件排序、贪心算法等方面提供了便利，并且可以作为一种有效的搜索算法工具

Queue接口

继承自 Collection 接口，表示队列集合。Queue是一种特殊的集合，按照先进先出（FIFO）的方式管理元素。常用的实现类有LinkedList、PriorityQueue等。

`使用 LinkedList 实现`

import java.util.Queue;
import java.util.LinkedList;public class QueueExample {public static void main(String[] args) {// 创建一个队列Queue<Integer> queue = new LinkedList<>();// 向队列中添加元素queue.offer(1);queue.offer(2);queue.offer(3);// 获取队列的大小System.out.println("队列大小: " + queue.size());// 检查队列是否为空System.out.println("队列是否为空: " + queue.isEmpty());// 访问队列头部的元素System.out.println("队列头部的元素: " + queue.peek());// 从队列中移除元素int removedElement = queue.poll();System.out.println("从队列中移除的元素: " + removedElement);// 遍历队列中的元素System.out.println("遍历队列中的元素:");for (int element : queue) {System.out.println(element);}}
}

`使用 PriorityQueue 实现`

import java.util.Queue;
import java.util.PriorityQueue;public class QueueExample {public static void main(String[] args) {// 创建一个优先级队列Queue<Integer> queue = new PriorityQueue<>();// 添加元素到队列queue.offer(5);queue.offer(2);queue.offer(8);queue.offer(1);// 获取并移除队列的头部元素int firstElement = queue.poll();System.out.println("从队列头部移除的元素: " + firstElement);// 获取队列的头部元素（不移除）int peekElement = queue.peek();System.out.println("队列头部的元素: " + peekElement);// 遍历队列中的元素System.out.println("遍历队列中的元素:");for (int element : queue) {System.out.println(element);}}
}

ArrayDeque、LinkedList

ArrayDeque 基于数组实现，它有固定的容量（默认情况下为16），但可以动态调整大小
ArrayDeque 支持高效的随机访问，因为它基于数组，可以通过索引快速访问元素
ArrayDeque 在操作两端的元素（队列头和队列尾）时，具有高效的时间复杂度（O(1)）

适用场景： 当你需要在队列的两端频繁地插入和删除元素时，例如实现栈、双向队列或循环队列等数据结构

LinkedList 基于双向链表实现，每个元素都包含前一个和后一个元素的引用
LinkedList 没有固定的容量限制，它可以根据需要动态调整大小
LinkedList 在插入和删除操作方面表现出色，特别是对于任意位置的元素操作
LinkedList 的随机访问效率较低，因为它需要遍历链表来到达目标位置

适用场景： 当你需要频繁地在任意位置插入和删除元素时，例如实现队列、栈、优先队列或循环缓冲区等数据结构

Deque接口

继承自 Queue 接口，表示双端队列集合。Deque支持在两端插入、删除元素，可以作为栈或队列使用。常用的实现类有ArrayDeque、LinkedList等。

`使用 ArrayDeque 实现`

import java.util.Deque;
import java.util.ArrayDeque;public class DequeExample {public static void main(String[] args) {// 创建一个双端队列Deque<Integer> deque = new ArrayDeque<>();// 向队列头部添加元素deque.offerFirst(1);deque.offerFirst(2);deque.offerFirst(3);// 向队列尾部添加元素deque.offerLast(4);deque.offerLast(5);// 从队列头部获取元素并移除int firstElement = deque.pollFirst();System.out.println("从队列头部移除的元素: " + firstElement);// 从队列尾部获取元素并移除int lastElement = deque.pollLast();System.out.println("从队列尾部移除的元素: " + lastElement);// 获取队列头部元素但不移除int peekFirstElement = deque.peekFirst();System.out.println("队列头部的元素: " + peekFirstElement);// 获取队列尾部元素但不移除int peekLastElement = deque.peekLast();System.out.println("队列尾部的元素: " + peekLastElement);// 遍历队列中的元素System.out.println("遍历队列中的元素:");for (int element : deque) {System.out.println(element);}}
}

`使用 LinkedList 实现`

import java.util.Deque;
import java.util.LinkedList;public class DequeExample {public static void main(String[] args) {// 创建一个双端队列Deque<Integer> deque = new LinkedList<>();// 添加元素到队列的头部和尾部deque.offerFirst(1);deque.offerLast(2);deque.offerFirst(3);deque.offerLast(4);// 获取并移除队列的头部和尾部元素int firstElement = deque.pollFirst();int lastElement = deque.pollLast();System.out.println("从队列头部移除的元素: " + firstElement);System.out.println("从队列尾部移除的元素: " + lastElement);// 获取队列的头部和尾部元素（不移除）int peekFirstElement = deque.peekFirst();int peekLastElement = deque.peekLast();System.out.println("队列头部的元素: " + peekFirstElement);System.out.println("队列尾部的元素: " + peekLastElement);// 遍历队列中的元素System.out.println("遍历队列中的元素:");for (int element : deque) {System.out.println(element);}}
}