💖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💖点点关注，收藏不迷路💖