在Java编程语言中，集合框架是一个非常重要的组成部分，它提供了丰富的类和方法来处理对象集合。以下是对Java集合框架中常用类的详细介绍。
1. List接口
List接口表示一个有序集合，即元素的位置可以改变，并且允许重复的元素。
1.1 ArrayList
ArrayList是List接口的实现类，基于动态数组实现，提供快速的随机访问。
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Element1");
list.add("Element2");
// 更多操作...
}
}
1.2 LinkedList
LinkedList是List接口的实现类，基于双向链表实现，适用于需要频繁插入和删除的场景。
import java.util.LinkedList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = new LinkedList<>();
list.add("Element1");
list.add("Element2");
// 更多操作...
}
}
1.3 Vector
Vector是List接口的实现类，与ArrayList类似，但它是线程安全的。
import java.util.Vector;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = new Vector<>();
list.add("Element1");
list.add("Element2");
// 更多操作...
}
}
1.4 Stack
Stack是Vector的一个子类，它实现了一个后进先出（LIFO）的数据结构。
import java.util.Stack;
public class Main {
public static void main(String[] args) {
Stack<String> stack = new Stack<>();
stack.push("Element1");
stack.push("Element2");
// 更多操作...
}
}
2. Set接口
Set接口表示一个没有重复元素的集合。
2.1 HashSet
HashSet基于哈希表实现，它不保持元素的顺序。
import java.util.HashSet;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("Element1");
set.add("Element2");
// 更多操作...
}
}
2.2 LinkedHashSet
LinkedHashSet是HashSet的一个子类，它基于哈希表实现，并维护了一个运行于所有条目的双重链接列表。
import java.util.LinkedHashSet;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<>();
set.add("Element1");
set.add("Element2");
// 更多操作...
}
}
2.3 TreeSet
TreeSet基于红黑树实现，它保持元素的排序。
import java.util.TreeSet;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Set<String> set = new TreeSet<>();
set.add("Element1");
set.add("Element2");
// 更多操作...
}
}
3. Map接口
Map接口表示一个键值对集合。
3.1 HashMap
HashMap基于哈希表实现，它不保持元素的顺序。
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("Key1", "Value1");
map.put("Key2", "Value2");
// 更多操作...
}
}
3.2 LinkedHashMap
LinkedHashMap是HashMap的一个子类，它基于哈希表实现，并维护了一个运行于所有条目的双向链表。
import java.util.LinkedHashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<String, String> map = new LinkedHashMap<>();
map.put("Key1", "Value1");
map.put("Key2", "Value2");
// 更多操作...
}
}
3.3 TreeMap
TreeMap基于红黑树实现，它保持键的排序。
import java.util.TreeMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<String, String> map = new TreeMap<>();
map.put("Key1", "Value1");
map.put("Key2", "Value2");
// 更多操作...
}
}
3.4 Properties
Properties是Map的一个实现类，它允许将键和值存储为字符串，并支持文件操作。
import java.util.Properties;
public class Main {
public static void main(String[] args) {
Properties properties = new Properties();
properties.setProperty("Key1", "Value1");
properties.setProperty("Key2", "Value2");
// 更多操作...
}
}
3.5 IdentityHashMap
IdentityHashMap是一个Map的实现类，它比较对象使用==操作符。
import java.util.IdentityHashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<Object, Object> map = new IdentityHashMap<>();
map.put(new Object(), "Value1");
map.put(new Object(), "Value2");
// 更多操作...
}
}
3.6 EnumMap
EnumMap是一个Map的实现类，它使用枚举的实例作为键。
import java.util.EnumMap;
import java.util.Map;
import java.util.Set;
public class Main {
enum Color {
RED, GREEN, BLUE
}
public static void main(String[] args) {
Map<Color, String> map = new EnumMap<>(Color.class);
map.put(Color.RED, "Red");
map.put(Color.GREEN, "Green");
map.put(Color.BLUE, "Blue");
// 更多操作...
}
}
4. Queue接口
Queue接口表示一个元素有序的集合，它按照元素插入的顺序进行操作。
4.1 PriorityQueue
PriorityQueue基于优先堆实现，它根据元素的优先级来排序。
import java.util.PriorityQueue;
import java.util.Queue;
public class Main {
public static void main(String[] args) {
Queue<String> queue = new PriorityQueue<>();
queue.add("Element1");
queue.add("Element2");
// 更多操作...
}
}
4.2 ArrayDeque
ArrayDeque基于数组实现，它支持高效的随机访问，并且实现了Deque接口。
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Queue;
public class Main {
public static void main(String[] args) {
Deque<String> deque = new ArrayDeque<>();
deque.add("Element1");
deque.add("Element2");
// 更多操作...
}
}
4.3 LinkedList
LinkedList实现了Queue接口，它基于双向链表实现，适用于需要频繁插入和删除的场景。
import java.util.LinkedList;
import java.util.Queue;
public class Main {
public static void main(String[] args) {
Queue<String> queue = new LinkedList<>();
queue.add("Element1");
queue.add("Element2");
// 更多操作...
}
}
5. Deque接口
Deque接口表示一个双端队列，它允许在两端进行插入和删除操作。
5.1 ArrayDeque
ArrayDeque基于数组实现，它支持高效的随机访问，并且实现了Deque接口。
import java.util.ArrayDeque;
import java.util.Deque;
public class Main {
public static void main(String[] args) {
Deque<String> deque = new ArrayDeque<>();
deque.addFirst("Element1");
deque.addLast("Element2");
// 更多操作...
}
}
5.2 LinkedList
LinkedList实现了Deque接口，它基于双向链表实现，适用于需要频繁插入和删除的场景。
import java.util.LinkedList;
import java.util.Deque;
public class Main {
public static void main(String[] args) {
Deque<String> deque = new LinkedList<>();
deque.addFirst("Element1");
deque.addLast("Element2");
// 更多操作...
}
}
6. Stack接口
Stack接口表示一个后进先出（LIFO）的数据结构。
6.1 Stack
Stack是Vector的一个子类，它实现了一个后进先出（LIFO）的数据结构。
import java.util.Stack;
public class Main {
public static void main(String[] args) {
Stack<String> stack = new Stack<>();
stack.push("Element1");
stack.push("Element2");
// 更多操作...
}
}
7. Iterator接口
Iterator接口用于遍历集合中的元素。
import java.util.Iterator;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Element1");
list.add("Element2");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String element = iterator.next();
System.out.println(element);
}
}
}
8. Collection接口
Collection接口是List、Set、Queue的父接口，它提供了一些通用的方法。
import java.util.Collection;
public class Main {
public static void main(String[] args) {
Collection<String> collection = new ArrayList<>();
collection.add("Element1");
collection.add("Element2");
// 更多操作...
}
}
9. ListIterator接口
ListIterator接口继承自Iterator，它提供了对List的遍历和修改操作。
import java.util.ListIterator;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Element1");
list.add("Element2");
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
String element = listIterator.next();
System.out.println(element);
}
}
}
10. Comparator接口
Comparator接口用于比较集合中的元素，实现自定义排序。
import java.util.Comparator;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");
list.sort(new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return s1.compareTo(s2);
}
});
// 更多操作...
}
}
11. Comparable接口
Comparable接口用于自然排序，实现自定义比较逻辑。
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
String[] array = {"Apple", "Banana", "Cherry"};
Arrays.sort(array);
// 更多操作...
}
}
12. CollectionUtils类
CollectionUtils类是Apache Commons Lang库中提供的一些集合操作工具类。
import org.apache.commons.lang3.StringUtils;
public class Main {
public static void main(String[] args) {
List<String> list = Arrays.asList("Apple", "Banana", "Cherry");
String joinedString = StringUtils.join(list, ",");
System.out.println(joinedString);
}
}
13. Arrays类
Arrays类是Java标准库中提供的一些数组操作工具类。
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
Integer[] array = {1, 2, 3};
Integer sum = Arrays.stream(array).sum();
System.out.println(sum);
}
}
以上是Java集合框架常用类的详细介绍，希望对您有所帮助。