ava 中的集合框架提供了多种集合类和接口,用于存储和操作数据。以下是你提到的一些关键集合类和接口的详细介绍:
1. HashSet 集合类
HashSet
是一个基于哈希表的集合类,它不保证集合的迭代顺序。HashSet
允许存储 null
元素,并且不允许重复的元素。
主要特点:
- 无序性:不保证元素的顺序。
- 唯一性:不允许重复元素。
- 性能:由于使用哈希表,插入、删除和查找操作的时间复杂度为 O(1)。
import java.util.HashSet;
public class HashSetExample {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Orange");
set.add("Apple"); // 重复元素不会被添加
for (String item : set) {
System.out.println(item);
}
}
}
2. LinkedHashSet 集合类
LinkedHashSet
是 HashSet
的一个子类,它具有哈希表和链表的性质。它保证迭代时按插入顺序排列元素。
主要特点:
- 有序性:按插入顺序排列元素。
- 唯一性:不允许重复元素。
- 性能:插入、删除和查找操作的时间复杂度为 O(1),但由于维护链表,性能略低于
HashSet
。
import java.util.LinkedHashSet;
public class LinkedHashSetExample {
public static void main(String[] args) {
LinkedHashSet<String> set = new LinkedHashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Orange");
set.add("Apple"); // 重复元素不会被添加
for (String item : set) {
System.out.println(item);
}
}
}
TreeSet
TreeSet
保证元素的有序性,并提供了比其他集合类更高效的集合操作。它的主要特点是:
- 有序性:
TreeSet
中的元素根据其自然顺序或根据提供的比较器排序。- 唯一性:
TreeSet
不允许重复元素。- 性能:
TreeSet
的基本操作(添加、删除和查找)的时间复杂度为 O(log n),因为它是基于红黑树(self-balancing binary search tree)实现的。
import java.util.TreeSet;
public class TreeSetExample {
public static void main(String[] args) {
TreeSet<String> set = new TreeSet<>();
set.add("Banana");
set.add("Apple");
set.add("Orange");
set.add("Apple"); // 重复元素不会被添加
// 遍历元素
for (String item : set) {
System.out.println(item);
}
// 检查是否包含某个元素
boolean containsBanana = set.contains("Banana");
System.out.println("Contains Banana: " + containsBanana);
// 获取第一个和最后一个元素
String first = set.first();
String last = set.last();
System.out.println("First: " + first + ", Last: " + last);
// 获取子集
TreeSet<String> subset = (TreeSet<String>) set.subSet("Apple", "Orange");
System.out.println("Subset: " + subset);
}
}
3. Collections 集合工具类
Collections
是一个包含各种静态方法的类,这些方法用于操作或返回集合。它提供了排序、搜索、线程安全化等实用工具。
主要功能:
- 排序:如
Collections.sort(List<T> list)
。- 搜索:如
Collections.binarySearch(List<? extends Comparable<? super T>> list, T key)
。- 线程安全化:如
Collections.synchronizedList(List<T> list)
。
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Banana");
list.add("Apple");
list.add("Orange");
Collections.sort(list); // 排序
for (String item : list) {
System.out.println(item);
}
}
}
4. Map 接口
Map
是一个接口,它映射唯一键到特定的值。常用的实现类包括 HashMap
、TreeMap
和 LinkedHashMap
。
主要特点:
- 键值对存储:每个键映射到一个值。
- 键的唯一性:不允许重复键,但允许重复值。
import java.util.HashMap;
import java.util.Map;
public class MapExample {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
map.put("Orange", 3);
System.out.println(map.get("Apple")); // 输出 1
}
}
Map 集合的遍历方式
Map
的遍历方式有多种,主要包括:
-
通过
keySet()
方法:
for (String key : map.keySet()) {
System.out.println("Key: " + key + ", Value: " + map.get(key));
}
-
通过
entrySet()
方法:
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}
-
通过
values()
方法:
for (Integer value : map.values()) {
System.out.println("Value: " + value);
}
5. 队列(Queue)
队列是一种先进先出(FIFO,First-In-First-Out)的数据结构,元素按照加入的顺序排列,最先加入的元素最先被移除。
常见的队列实现类:
-
LinkedList:Java 中的
LinkedList
类实现了Queue
接口,可以作为队列使用。 -
ArrayDeque:
ArrayDeque
类也实现了Queue
接口,底层使用数组实现。
主要方法和特性:
offer(E e)
:向队列尾部添加一个元素,并返回true
;如果队列已满,则返回false
。poll()
:移除并返回队列头部的元素;如果队列为空,则返回null
。peek()
:返回队列头部的元素,但不移除;如果队列为空,则返回null
。isEmpty()
:判断队列是否为空。size()
:返回队列中的元素数量。
-
LinkedList:
java.util.LinkedList
实现了Queue
接口,可以作为队列使用。它既可以作为队列,也可以作为双端队列(Deque)使用。- 示例:
-
Queue<String> queue = new LinkedList<>(); queue.offer("item1"); queue.offer("item2"); String item = queue.poll(); // 出队列
-
ArrayDeque:
java.util.ArrayDeque
是一个双端队列的实现,也可以用作队列。它比LinkedList
更高效,因为使用了数组来存储元素。- 示例:
-
Queue<String> queue = new ArrayDeque<>(); queue.offer("item1"); queue.offer("item2"); String item = queue.poll(); // 出队列
-
PriorityQueue:
java.util.PriorityQueue
是一个优先级队列,它不是严格的先进先出队列,而是根据元素的优先级进行排序。- 示例:
-
Queue<Integer> queue = new PriorityQueue<>(); queue.offer(3); queue.offer(1); queue.offer(2); int item = queue.poll(); // 出队列,会返回最小的元素
6. 栈(Stack)
栈是一种后进先出(LIFO,Last-In-First-Out)的数据结构,最后加入的元素最先被移除。
Java 中的栈实现:
- Stack 类:Java 提供了
java.util.Stack
类来实现栈。 - ArrayDeque
主要方法和特性:
push(E item)
:将元素推入栈顶。pop()
:移除并返回栈顶的元素。peek()
:返回栈顶的元素,但不移除。isEmpty()
:判断栈是否为空。search(Object o)
:返回元素在栈中的位置,以 1 开始计数;如果不存在,则返回-1
。
-
Stack:
java.util.Stack
是 Java 提供的经典栈的实现类,它继承自Vector
类,因此是一个线程安全的类,但在性能上不如ArrayDeque
。- 示例:
-
Stack<String> stack = new Stack<>(); stack.push("item1"); stack.push("item2"); String item = stack.pop(); // 出栈
-
ArrayDeque:
java.util.ArrayDeque
也可以用作栈的实现,它同样支持在栈顶进行元素的入栈和出栈操作,并且比Stack
更高效。- 示例:
-
Deque<String> stack = new ArrayDeque<>(); stack.push("item1"); stack.push("item2"); String item = stack.pop(); // 出栈