当前位置：首页 > article >正文

Java中的集合

article 2025/3/7 6:22:26

1. 集合框架的核心接口

(1) Collection 接口

(2) Map 接口

2. List 接口的实现类

(1) ArrayList

(2) LinkedList

(3) Vector

(4) Stack

3. Set 接口的实现类

(1) HashSet

(2) LinkedHashSet

(3) TreeSet

4. Queue 接口的实现类

(1) LinkedList

(2) PriorityQueue

5. Map 接口的实现类

(1) HashMap

(2) LinkedHashMap

(3) TreeMap

(4) Hashtable

其它. 工具类

(1) Collections

(2) Arrays

并发集合

(1) ConcurrentHashMap

(2) CopyOnWriteArrayList

总结

在 Java 中，集合（Collection）是用于存储和操作一组对象的框架。Java 集合框架（Java Collections Framework）提供了丰富的接口和类，用于处理不同类型的集合。以下是 Java 中常见的集合分类及其实现类

1. 集合框架的核心接口

Java 集合框架的核心接口位于 java.util 包中，主要包括：

(1) `Collection` 接口

是所有集合类的根接口。
主要子接口：
- List：有序且允许重复元素的集合。
- Set：无序且不允许重复元素的集合。
- Queue：队列，遵循先进先出（FIFO）原则。

(2) `Map` 接口

存储键值对（key-value pairs），键不允许重复。
不是 Collection 的子接口，但属于集合框架的一部分

2. List 接口的实现类

List 是有序集合，允许重复元素。

(1) `ArrayList`

基于动态数组实现。
查询快，增删慢。
线程不安全。
示例：

List<String> list = new ArrayList<>();
list.add("App");
list.add("Bana");

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.remove(1); // 删除索引为1的元素（即数字2）
        System.out.println(numbers); // 输出：[1, 3]
    }
}

(2) `LinkedList`

基于双向链表实现。
增删快，查询慢。
可以用作队列或栈。

示例：

List<String> list = new LinkedList<>();
list.add("Apple");
list.add("Banana");

(3) `Vector`

类似于 ArrayList，但线程安全。
性能较低，已逐渐被 ArrayList 取代。
示例：

List<String> list = new Vector<>();
list.add("Apple");
list.add("Banana");

(4) `Stack`

Vector 的子类，实现栈结构（后进先出，LIFO）

Stack<String> stack = new Stack<>();
stack.push("Apple");
stack.push("Banana");
stack.pop(); // 返回 "Banana"

3. Set 接口的实现类

Set 是无序集合，不允许重复元素。

(1) `HashSet`

基于哈希表实现。
查询速度快，元素无序。
示例

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");

(2) `LinkedHashSet`

基于哈希表和链表实现。
元素按插入顺序排序。
示例

Set<String> set = new LinkedHashSet<>();
set.add("Apple");
set.add("Banana");

(3) `TreeSet`

基于红黑树实现。
元素按自然顺序或自定义顺序排序。
示例：

Set<String> set = new TreeSet<>();
set.add("Apple");
set.add("Banana");

4. Queue 接口的实现类

Queue 是队列，遵循先进先出（FIFO）原则。

(1) `LinkedList`

(2) `LinkedHashMap`

可以用作队列。
示例：

Queue<String> queue = new LinkedList<>();
queue.offer("Apple");
queue.offer("Banana");
queue.poll(); // 返回 "Apple"

(2) `PriorityQueue`

基于优先级堆实现。
元素按优先级排序。
示例

Queue<String> queue = new PriorityQueue<>();
queue.offer("Apple");
queue.offer("Banana");
queue.poll(); // 返回 "Apple"

5. Map 接口的实现类

Map 存储键值对，键不允许重复。

(1) `HashMap`

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

Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);

基于哈希表和链表实现。
键值对按插入顺序排序。

Map<String, Integer> map = new LinkedHashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);

(3) `TreeMap`

基于红黑树实现。
键值对按自然顺序或自定义顺序排序。

示例：

Map<String, Integer> map = new TreeMap<>();
map.put("Apple", 1);
map.put("Banana", 2);

(4) `Hashtable`

(2) `Arrays`

类似于 HashMap，但线程安全。
性能较低，已逐渐被 HashMap 取代。

示例：

Map<String, Integer> map = new Hashtable<>();
map.put("Apple", 1);
map.put("Banana", 2);

其它. 工具类

Java 集合框架还提供了一些工具类，用于操作集合。

(1) Collections
提供静态方法操作集合，如排序、查找、反转等。
示例：

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
Collections.sort(list); // 排序

提供静态方法操作数组，如排序、查找等。
示例：
```
String[] array = {"Apple", "Banana"};
Arrays.sort(array); // 排序
```
并发集合

Java 还提供了一些线程安全的集合类，位于 java.util.concurrent 包中。

(1) ConcurrentHashMap
线程安全的 HashMap。

Map<String, Integer> map = new ConcurrentHashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);

(2) `CopyOnWriteArrayList`

线程安全的 ArrayList。

示例：

List<String> list = new CopyOnWriteArrayList<>();
list.add("Apple");
list.add("Banana");

总结

Java 集合框架提供了丰富的接口和类，用于处理不同类型的集合。以下是常用集合的分类：

接口	实现类	特点
`List`	`ArrayList`, `LinkedList`	有序，允许重复
`Set`	`HashSet`, `TreeSet`	无序，不允许重复
`Queue`	`LinkedList`, `PriorityQueue`	队列，先进先出或优先级排序
`Map`	`HashMap`, `TreeMap`	键值对，键不允许重复
并发集合	`ConcurrentHashMap`	线程安全