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

Java集合框架整体分类（完整的集合框架关系）

news 2025/10/23 10:04:25

Java集合框架整体分类

- 完整的集合框架关系
- - 1. Collection接口（单列集合）
  - - List（有序、可重复）
    - Set（无序、不可重复）
    - Queue（队列）
  - 2. Map接口（双列集合）
- 栈和队列在集合框架中的位置
- - 栈（Stack）的实现
  - 队列（Queue）的实现
  - 双端队列（Deque）的实现
- 使用建议

完整的集合框架关系

Collection接口
├── List接口（有序可重复）
│   ├── ArrayList
│   ├── LinkedList  
│   └── Vector
│
├── Set接口（无序不可重复）
│   ├── HashSet
│   ├── LinkedHashSet
│   └── TreeSet
│
└── Queue接口（队列）├── LinkedList├── PriorityQueue└── Deque接口（双端队列）├── ArrayDeque└── LinkedListMap接口（键值对）
├── HashMap
├── LinkedHashMap
├── TreeMap
└── Hashtable

1. Collection接口（单列集合）

存储单个对象的集合，分为三大类：

List（有序、可重复）

// ArrayList - 基于数组，查询快，增删慢
List<String> arrayList = new ArrayList<>();
arrayList.add("Java");
arrayList.add("Python");
arrayList.add("Java"); // 可重复// LinkedList - 基于链表，增删快，查询慢
List<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);// Vector - 线程安全，已过时
List<String> vector = new Vector<>();

Set（无序、不可重复）

// HashSet - 基于哈希表，无序
Set<String> hashSet = new HashSet<>();
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Apple"); // 不会重复添加// LinkedHashSet - 保持插入顺序
Set<Integer> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(3);
linkedHashSet.add(1);
linkedHashSet.add(2); // 输出顺序：3,1,2// TreeSet - 自然排序或定制排序
Set<String> treeSet = new TreeSet<>();
treeSet.add("Orange");
treeSet.add("Apple");
treeSet.add("Banana"); // 输出顺序：Apple, Banana, Orange

Queue（队列）

// LinkedList 实现队列
Queue<String> queue = new LinkedList<>();
queue.offer("A");
queue.offer("B");
queue.poll(); // A// PriorityQueue - 优先级队列
Queue<Integer> priorityQueue = new PriorityQueue<>();
priorityQueue.offer(5);
priorityQueue.offer(1); // 1会先出队// ArrayDeque - 双端队列，也可用作栈
Queue<String> arrayDeque = new ArrayDeque<>();

2. Map接口（双列集合）

存储键值对的集合

// HashMap - 基于哈希表，无序
Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("Alice", 25);
hashMap.put("Bob", 30);// LinkedHashMap - 保持插入顺序
Map<String, String> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("key1", "value1");
linkedHashMap.put("key2", "value2");// TreeMap - 按键排序
Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Orange", 5);
treeMap.put("Apple", 3); // 按键字母顺序排序// Hashtable - 线程安全，已过时
Map<String, String> hashtable = new Hashtable<>();

栈和队列在集合框架中的位置

栈（Stack）的实现

// 方式1：使用Stack类（继承自Vector，不推荐）
Stack<Integer> stack1 = new Stack<>();
stack1.push(1);
stack1.pop();// 方式2：使用Deque接口的实现类（推荐）
Deque<Integer> stack2 = new ArrayDeque<>();  // 或 LinkedList
stack2.push(1);
stack2.push(2);
stack2.pop(); // 2

队列（Queue）的实现

// LinkedList实现
Queue<String> queue1 = new LinkedList<>();
queue1.offer("A");
queue1.poll();// ArrayDeque实现  
Queue<Integer> queue2 = new ArrayDeque<>();
queue2.offer(1);
queue2.poll();

双端队列（Deque）的实现

Deque<String> deque = new ArrayDeque<>();
// 作为栈使用
deque.push("A");
deque.pop();// 作为队列使用
deque.offer("B");
deque.poll();// 双端操作
deque.offerFirst("C");
deque.offerLast("D");