代码收藏家 Java集合类详解：List、Set、Queue、Map、Stack的特点与用法【面试干货】
【面试干货】Java集合类详解：List、Set、Queue、Map、Stack的特点与用法
|
💖The Begin💖点点关注，收藏不迷路💖 |
在Java中，集合类（Collections Framework）是一个非常重要的部分，它提供了多种数据结构的实现，以便我们在开发中更方便地管理和操作数据。
本文将详细介绍Java中的几种主要集合类：List、Set、Queue、Map和Stack的特点和用法。
1、Map
Map是一个键值对集合，键（Key）唯一不能重复，一个键对应一个值（Value），值可以重复。
在Map中，可以通过KeySet()方法将所有的键抽取成一个Set集合，这样就可以方便地遍历所有的键；而Values()方法则可以将Map中所有的值抽取成一个集合，同样便于对值进行遍历操作。
1.1 特点
1、键（Key）唯一不能重复。
2、可以将Key和Value单独抽取出来，例如keySet()和values()方法。
3、TreeMap可以保证顺序，HashMap不保证顺序。
1.2 用法
Map<String, Integer> map = new HashMap<>();
map.put("One", 1);
map.put("Two", 2);
System.out.println(map.get("One")); // 输出 1
1.3 常见的实现类
1、HashMap：基于哈希表实现，不保证顺序。
2、LinkedHashMap：基于链表和哈希表实现，维护插入顺序。
3、TreeMap：基于红黑树实现，保证键的自然顺序或自定义排序。
Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("a", 1);
hashMap.put("b", 2);
Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("c", 3);
treeMap.put("d", 4);
Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("e", 5);
linkedHashMap.put("f", 6);
linkedHashMap.put("g", 7);
2、Set
Set是一个不包含重复元素的集合。
2.1 特点
1、元素唯一不重复。
2、Set中最多包含一个null元素。
3、只能使用Iterator实现单项遍历。
4、Set 中没有同步方法。
2.2 用法
Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Apple"); // 不会添加重复元素
for (String fruit : set) {
System.out.println(fruit);
}
2.3 常见的实现类
1、HashSet：基于哈希表实现，不保证顺序。
2、LinkedHashSet：基于链表和哈希表实现，维护插入顺序。
3、TreeSet：基于红黑树实现，保证元素的自然顺序或自定义排序。
用法示例：
Set<String> hashSet = new HashSet<>();
hashSet.add("one");
hashSet.add("two");
Set<String> treeSet = new TreeSet<>();
treeSet.add("three");
treeSet.add("four");
Set<String> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add("five");
linkedHashSet.add("six");
linkedHashSet.add("seven");
3、List
List是一个有序的可重复集合。
3.1 特点
1、元素有序。
2、元素可重复。
3、可以在任意位置增加、删除元素。
4、List可以使用Iterator进行单向遍历，也可以使用ListIterator进行双向遍历。
遍历示例：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class ListIteratorExample {
public static void main(String[] args) {
// 创建一个列表并添加一些元素
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
// 使用 Iterator 进行单向遍历
System.out.println("使用 Iterator 遍历列表:");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String element = iterator.next();
System.out.print(element + " ");
}
System.out.println();
// 使用 ListIterator 进行双向遍历
System.out.println("\n使用 ListIterator 进行双向遍历:");
ListIterator<String> listIterator = list.listIterator();
// 向前遍历列表
System.out.println("向前遍历:");
while (listIterator.hasNext()) {
String element = listIterator.next();
System.out.print(element + " ");
}
System.out.println();
// 向后遍历列表
System.out.println("向后遍历:");
while (listIterator.hasPrevious()) {
String element = listIterator.previous();
System.out.print(element + " ");
}
System.out.println();
}
}
3.2 用法
List<String> list = new ArrayList<>();
list.add("First");
list.add("Second");
list.add(1, "Inserted"); // 在索引1处插入元素
System.out.println(list.get(1)); // 输出 Inserted
3.3 常见的实现类
1、ArrayList：基于动态数组，支持快速随机访问。
2、LinkedList：基于双向链表，适合需要频繁插入和删除元素的场景。
用法示例：
List<Integer> arrayList = new ArrayList<>();
arrayList.add(1);
arrayList.add(2);
List<Integer> linkedList = new LinkedList<>();
linkedList.add(3);
linkedList.add(4);
4、Queue
Queue是一个遵循先进先出（FIFO）原则的集合。
4.1 特点
1、遵循FIFO原则。
2、使用offer()添加元素，poll()移除元素，可以通过返回值判断操作是否成功。
3、通常不允许插入null元素。
4.2 用法
Queue<String> queue = new LinkedList<>();
queue.offer("First");
queue.offer("Second");
System.out.println(queue.poll()); // 输出 First
4.3 常见的实现类
1、LinkedList：可以作为队列使用，支持双端队列。
2、PriorityQueue：基于优先级堆实现，元素按优先级顺序出队。
Queue<Integer> linkedList= new LinkedList<>();
queue.offer(1);
queue.offer(2);
Integer head = linkedList.poll();
Queue<Integer> priorityQueue = new PriorityQueue<>();
// 添加元素到优先级队列
priorityQueue.offer(5);
priorityQueue.offer(1);
priorityQueue.offer(3);
// 获取并移除队列头部的元素
Integer head = priorityQueue.poll();
5、Stack
Stack是一个遵循后进先出（LIFO）原则的集合。
5.1 特点
1、遵循LIFO原则。
2、提供了push()、pop()、peek()等方法。
3、Stack继承自Vector，但通常不建议直接使用Stack，因为Vector是同步的，而Stack的方法并不是线程安全的。
5.2 用法（但不建议直接使用Stack类）
Deque<String> stack = new ArrayDeque<>(); // 使用Deque实现Stack的功能
stack.push("First");
stack.push("Second");
System.out.println(stack.pop()); // 输出 Second
尽管Stack类存在，但在实际开发中，建议使用Deque接口及其实现类（如ArrayDeque）来代替，因为Deque提供了更丰富的功能和更好的性能。
6、用法总结建议
1、如果涉及堆栈或队列操作，建议使用List或Deque。
2、对于快速插入和删除元素，建议使用LinkedList。
3、如果需要快速随机访问元素，建议使用ArrayList。
但实际上：如果涉及堆栈，队列等操作，对于Stack和Queue，应该使用专门为此设计的集合类（如Deque和Queue接口的实现类），因为它们提供了更适合这些数据结构操作的方法。
对于快速插入和删除元素的场景，LinkedList是一个很好的选择，因为它在列表的任意位置插入和删除元素的时间复杂度都是O(1)。
如果需要快速随机访问元素，则应该使用ArrayList，因为ArrayList是基于数组实现的，可以通过索引快速访问元素。
|
💖The End💖点点关注，收藏不迷路💖 |
作者：Seal^_^
