深入解析Java集合框架
文章目录
ArrayList
ArrayList 是 List 接口的实现之一，它是一个动态数组，允许随机访问元素。内部使用一个对象数组来存储元素，并在需要时自动扩容。
import java.util.ArrayList;
public class ArrayListDetailed {
public static void main(String[] args) {
// 创建一个ArrayList实例
ArrayList<String> list = new ArrayList<>();
// 添加元素
list.add("Apple");
list.add("Banana");
list.add("Orange");
// 访问元素（通过索引）
System.out.println("Element at index 1: " + list.get(1)); // 输出: Element at index 1: Banana
// 修改元素
list.set(1, "Grapes");
System.out.println("Updated list: " + list); // 输出: Updated list: [Apple, Grapes, Orange]
// 删除元素
list.remove("Apple"); // 或者使用索引：list.remove(0);
System.out.println("After removal: " + list); // 输出: After removal: [Grapes, Orange]
// 遍历列表
for (String fruit : list) {
System.out.println(fruit);
}
}
}
LinkedList
LinkedList 实现了 List 和 Deque 接口，内部以双向链表形式存储元素。适合频繁的插入和删除操作。
import java.util.LinkedList;
public class LinkedListDetailed {
public static void main(String[] args) {
LinkedList<String> linkedList = new LinkedList<>();
linkedList.addFirst("First");
linkedList.addLast("Last");
linkedList.add("Middle");
System.out.println("Original list: " + linkedList); // 输出: Original list: [First, Middle, Last]
// 移除第一个元素
String first = linkedList.removeFirst();
System.out.println("Removed first element: " + first); // 输出: Removed first element: First
// 获取但不移除最后一个元素
String last = linkedList.peekLast();
System.out.println("Peeked last element: " + last); // 输出: Peeked last element: Last
// 使用迭代器遍历
for (String item : linkedList) {
System.out.println(item);
}
}
}
Vector
Vector 类似于 ArrayList，但它所有的方法都是同步的，因此是线程安全的。不过，由于同步机制，性能通常比 ArrayList 差。
import java.util.Vector;
public class VectorDetailed {
public static void main(String[] args) {
Vector<Integer> vector = new Vector<>();
synchronized (vector) { // 显式同步块
vector.add(1);
vector.add(2);
vector.add(3);
}
// 使用迭代器遍历
for (Integer i : vector) {
System.out.println(i);
}
}
}
Set (HashSet)
Set 是一个不允许重复元素的集合。HashSet 是 Set 的典型实现，它提供了常数时间复杂度的添加、删除和查找操作。
import java.util.HashSet;
import java.util.Set;
public class HashSetDetailed {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Apple"); // 不会添加重复元素
// 检查是否包含某个元素
System.out.println("Contains Apple? " + set.contains("Apple")); // 输出: Contains Apple? true
// 遍历Set
for (String fruit : set) {
System.out.println(fruit);
}
}
}
Queue (PriorityQueue)
Queue 是一个先进先出的数据结构。PriorityQueue 是一种特殊的队列，其中元素按照优先级排序。
import java.util.PriorityQueue;
import java.util.Queue;
public class PriorityQueueExample {
public static void main(String[] args) {
Queue<Integer> queue = new PriorityQueue<>(); // 默认是最小堆
queue.offer(10);
queue.offer(5);
queue.offer(20);
// 取出并移除队首元素
while (!queue.isEmpty()) {
System.out.println(queue.poll()); // 输出: 5, 10, 20
}
}
}
HashMap
HashMap 实现了 Map 接口，允许键值对存储。非线程安全，但提供了快速的存取速度。
import java.util.HashMap;
import java.util.Map;
public class HashMapDetailed {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("Alice", 23);
map.put("Bob", 29);
// 获取值
System.out.println("Age of Alice: " + map.get("Alice")); // 输出: Age of Alice: 23
// 检查是否存在键
System.out.println("Contains key 'Charlie'? " + map.containsKey("Charlie")); // 输出: false
// 遍历键值对
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
}
}
TreeMap
TreeMap 实现了 SortedMap 接口，能够根据键进行自然排序或自定义排序。
import java.util.TreeMap;
public class TreeMapDetailed {
public static void main(String[] args) {
TreeMap<Integer, String> treeMap = new TreeMap<>();
treeMap.put(3, "Three");
treeMap.put(1, "One");
treeMap.put(2, "Two");
// 自动按键排序
System.out.println(treeMap); // 输出: {1=One, 2=Two, 3=Three}
// 获取最大/最小键
System.out.println("Lowest key: " + treeMap.firstKey()); // 输出: Lowest key: 1
System.out.println("Highest key: " + treeMap.lastKey()); // 输出: Highest key: 3
}
}
ConcurrentHashMap
ConcurrentHashMap 提供了更高的并发性，适用于多线程环境。
import java.util.concurrent.ConcurrentHashMap;
public class ConcurrentHashMapDetailed {
public static void main(String[] args) {
ConcurrentHashMap<Integer, String> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put(1, "Value1");
concurrentMap.putIfAbsent(1, "NewValue"); // 不会替换已有的键
// 线程安全地获取和更新
String oldValue = concurrentMap.replace(1, "Value1", "ReplacedValue");
System.out.println("Old value replaced: " + oldValue); // 输出: Old value replaced: Value1
}
}
Comparable 和 Comparator
Comparable 接口用于定义类的自然排序规则，而 Comparator 接口允许定义额外的排序逻辑。
import java.util.Arrays;
import java.util.Comparator;
class Person implements Comparable<Person> {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Person other) {
return Integer.compare(this.age, other.age);
}
public static final Comparator<Person> NAME_COMPARATOR = Comparator.comparing(p -> p.name);
@Override
public String toString() {
return name + ":" + age;
}
}
public class ComparatorDetailed {
public static void main(String[] args) {
Person[] people = {
new Person("John", 30),
new Person("Jane", 25)
};
Arrays.sort(people); // 使用自然排序（按年龄）
System.out.println("Sorted by age: " + Arrays.toString(people));
Arrays.sort(people, Person.NAME_COMPARATOR); // 使用自定义比较器（按名字）
System.out.println("Sorted by name: " + Arrays.toString(people));
}
}
原文地址：https://blog.csdn.net/2301_77163982/article/details/144359192
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！