Java应用7（类集）
1. Collection 接口
Collection 是集合框架的根接口，定义了集合的基本操作，如添加、删除、查询元素等。它有两个主要的子接口：List 和 Set。
java
import java.util.ArrayList;
import java.util.Collection;
public class CollectionExample {
public static void main(String[] args) {
Collection collection = new ArrayList<>();
collection.add("element1");
collection.add("element2");
System.out.println("Collection size: " + collection.size());
System.out.println("Collection contains 'element1': " + collection.contains("element1"));
collection.remove("element1");
System.out.println("Collection size after removal: " + collection.size());
}
}
上述代码创建了一个 ArrayList 实例，并将其赋值给 Collection 类型的引用变量，展示了 Collection 接口的基本操作。
2. List 接口
List 是一个有序的集合，允许重复元素。它提供了基于索引的访问方式，常见的实现类有：
2.1 ArrayList
- 特点：基于动态数组实现，支持随机访问，访问速度快，但插入和删除操作效率较低，尤其是在数组中间位置。
- 使用场景：适用于需要频繁随机访问元素，而插入和删除操作较少的场景。
java
import java.util.ArrayList;
import java.util.List;
public class ArrayListExample {
public static void main(String[] args) {
List list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add(1, "cherry"); // 在指定位置插入元素
System.out.println("Element at index 1: " + list.get(1));
list.remove(2); // 删除指定位置的元素
for (String fruit : list) {
System.out.println(fruit);
}
}
}
2.2 LinkedList
- 特点：基于双向链表实现，插入和删除操作效率高，尤其是在链表头部和尾部，但随机访问速度较慢。
- 使用场景：适用于需要频繁进行插入和删除操作，而随机访问较少的场景。
java
import java.util.LinkedList;
import java.util.List;
public class LinkedListExample {
public static void main(String[] args) {
List list = new LinkedList<>();
list.add("apple");
list.add("banana");
((LinkedList) list).addFirst("cherry"); // 在链表头部添加元素
((LinkedList) list).addLast("date"); // 在链表尾部添加元素
System.out.println("First element: " + ((LinkedList) list).getFirst());
System.out.println("Last element: " + ((LinkedList) list).getLast());
((LinkedList) list).removeFirst(); // 删除链表头部元素
((LinkedList) list).removeLast(); // 删除链表尾部元素
for (String fruit : list) {
System.out.println(fruit);
}
}
}
2.3 Vector
- 特点：与
ArrayList类似，也是基于动态数组实现，但它是线程安全的，不过性能相对较低。 - 使用场景：适用于多线程环境下需要保证线程安全的场景。
java
import java.util.List;
import java.util.Vector;
public class VectorExample {
public static void main(String[] args) {
List list = new Vector<>();
list.add("apple");
list.add("banana");
System.out.println("Vector size: " + list.size());
for (String fruit : list) {
System.out.println(fruit);
}
}
}
3. Set 接口
Set 是一个不允许重复元素的集合，常见的实现类有：
3.1 HashSet
- 特点：基于哈希表实现，不保证元素的顺序，插入、删除和查找操作的时间复杂度为 O (1)。
- 使用场景：适用于需要快速查找元素且不关心元素顺序的场景。
java
import java.util.HashSet;
import java.util.Set;
public class HashSetExample {
public static void main(String[] args) {
Set set = new HashSet<>();
set.add("apple");
set.add("banana");
set.add("apple"); // 重复元素，不会被添加
System.out.println("Set size: " + set.size());
for (String fruit : set) {
System.out.println(fruit);
}
}
}
3.2 TreeSet
- 特点：基于红黑树实现，元素会按照自然顺序或指定的比较器顺序进行排序。插入、删除和查找操作的时间复杂度为 O (log n)。
- 使用场景：适用于需要对元素进行排序的场景。
java
import java.util.Set;
import java.util.TreeSet;
public class TreeSetExample {
public static void main(String[] args) {
Set set = new TreeSet<>();
set.add("banana");
set.add("apple");
set.add("cherry");
for (String fruit : set) {
System.out.println(fruit); // 按字母顺序输出
}
}
}
3.3 LinkedHashSet
- 特点：基于哈希表和链表实现，它维护了元素插入的顺序，插入、删除和查找操作的时间复杂度为 O (1)。
- 使用场景：适用于需要保证元素插入顺序的场景。
java
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSetExample {
public static void main(String[] args) {
Set set = new LinkedHashSet<>();
set.add("banana");
set.add("apple");
set.add("cherry");
for (String fruit : set) {
System.out.println(fruit); // 按插入顺序输出
}
}
}
4. Queue 接口
Queue 用于在处理前保存元素，通常遵循先进先出（FIFO）原则，常见的实现类有：
4.1 LinkedList
LinkedList 不仅实现了 List 接口，还实现了 Queue 接口，可作为队列使用。
java
import java.util.LinkedList;
import java.util.Queue;
public class QueueExample {
public static void main(String[] args) {
Queue queue = new LinkedList<>();
queue.offer("apple");
queue.offer("banana");
System.out.println("Head of the queue: " + queue.peek());
System.out.println("Removed element: " + queue.poll());
System.out.println("Queue size after removal: " + queue.size());
}
}
4.2 PriorityQueue
- 特点：基于优先级堆实现，元素按照优先级进行排序，优先级高的元素先出队。
- 使用场景：适用于需要根据元素优先级进行处理的场景。
java
import java.util.PriorityQueue;
import java.util.Queue;
public class PriorityQueueExample {
public static void main(String[] args) {
Queue queue = new PriorityQueue<>();
queue.offer(3);
queue.offer(1);
queue.offer(2);
while (!queue.isEmpty()) {
System.out.println(queue.poll()); // 按升序输出
}
}
}
5. Map 接口
Map 是一种键值对的映射集合，键不能重复，常见的实现类有：
5.1 HashMap
- 特点：基于哈希表实现，不保证键值对的顺序，插入、删除和查找操作的时间复杂度为 O (1)。
- 使用场景：适用于需要快速查找键对应的值的场景。
java
import java.util.HashMap;
import java.util.Map;
public class HashMapExample {
public static void main(String[] args) {
Map map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);
System.out.println("Value of 'apple': " + map.get("apple"));
map.remove("banana");
for (Map.Entry entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
}
}
5.2 TreeMap
- 特点：基于红黑树实现，键会按照自然顺序或指定的比较器顺序进行排序。插入、删除和查找操作的时间复杂度为 O (log n)。
- 使用场景：适用于需要对键进行排序的场景。
java
import java.util.Map;
import java.util.TreeMap;
public class TreeMapExample {
public static void main(String[] args) {
Map map = new TreeMap<>();
map.put("banana", 2);
map.put("apple", 1);
map.put("cherry", 3);
for (Map.Entry entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue()); // 按键的字母顺序输出
}
}
}
5.3 LinkedHashMap
- 特点：基于哈希表和链表实现，它维护了键值对插入的顺序，插入、删除和查找操作的时间复杂度为 O (1)。
- 使用场景：适用于需要保证键值对插入顺序的场景。