Java Collections Framework: List, Set, Map & Generics

Collection Hierarchy

The Collections Framework sits in java.util. Collection has three main branches: List (ordered, allows duplicates), Set (no duplicates) and Queue; Map is a separate top-level interface for key-value pairs.

List<String> list = new ArrayList<>();     // 数组实现
Set<Integer> set = new HashSet<>();          // 哈希实现
Map<String, Integer> map = new HashMap<>(); // 哈希表实现
Queue<String> q = new LinkedList<>();       // 队列

// 工具类：不可变集合
List<String> fixed = List.of("a", "b");
Map<String, Integer> m2 = Map.of("x", 1, "y", 2);

List: ArrayList vs LinkedList

Feature	ArrayList	LinkedList
Backing storage	Dynamic array	Doubly linked list
Random access get(i)	O(1)	O(n)
Insert/remove at head	O(n)	O(1)
Memory overhead	Low	High (node pointers)
Typical use	Read-mostly lists, 90% of cases	Frequent head/tail ops, deque

List<String> names = new ArrayList<>();
names.add("Java");
names.add(0, "Go");            // 指定位置插入
names.set(1, "Python");
names.remove("Go");
names.get(0);
names.size();
names.contains("Java");

Set and Map

HashSet gives O(1) add/contains but unordered; TreeSet keeps elements sorted (needs Comparable or Comparator). HashMap is the king of Map:桶数组 + 链表/红黑树 (a bucket array with a linked list that converts to a red-black tree at 8 entries).

Set<String> set = new HashSet<>();
set.add("mysql");
set.add("redis");
set.add("mysql");            // 重复元素被忽略
set.size();                    // 2

Map<String, Integer> map = new HashMap<>();
map.put("java", 1);
map.put("go", 2);
map.get("java");               // 1
map.getOrDefault("rust", 0);   // 0
map.containsKey("go");
map.forEach((k, v) -> System.out.println(k + "=" + v));

// 遍历 Map
for (var e : map.entrySet()) {
    System.out.println(e.getKey() + ": " + e.getValue());
}

Sorting and Generics

// 泛型保证类型安全
List<Integer> nums = new ArrayList<>();
nums.add(3); nums.add(1); nums.add(2);
Collections.sort(nums);                 // 自然序
nums.sort(Comparator.reverseOrder());   // 降序

// 按字段排序（Comparator 链）
List<User> users = new ArrayList<>();
users.sort(Comparator.comparing(User::getName)
                     .thenComparing(User::getId));

// Comparable：类自带排序规则
class User implements Comparable<User> {
    Long id; String name;
    public int compareTo(User o) { return id.compareTo(o.id); }
}

Use the diamond operator <> to avoid repeating type arguments, and never use raw types (List without generics) in new code — you lose compile-time type safety.

集合体系结构

集合框架位于 java.util 包。Collection 有三大分支：List（有序、可重复）、Set（不可重复）和 Queue；Map 是独立的顶层接口，用于键值对存储。

List<String> list = new ArrayList<>();     // 数组实现
Set<Integer> set = new HashSet<>();          // 哈希实现
Map<String, Integer> map = new HashMap<>(); // 哈希表实现
Queue<String> q = new LinkedList<>();       // 队列

// 工具类：不可变集合
List<String> fixed = List.of("a", "b");
Map<String, Integer> m2 = Map.of("x", 1, "y", 2);

List：ArrayList 与 LinkedList

特性	ArrayList	LinkedList
底层结构	动态数组	双向链表
随机访问 get(i)	O(1)	O(n)
头部插入/删除	O(n)	O(1)
内存开销	小	大（节点指针）
典型场景	读多写少，90% 场景首选	频繁头尾操作，双端队列

List<String> names = new ArrayList<>();
names.add("Java");
names.add(0, "Go");            // 指定位置插入
names.set(1, "Python");
names.remove("Go");
names.get(0);
names.size();
names.contains("Java");

Set 与 Map

HashSet 的增删查为 O(1) 但无序；TreeSet 保持元素有序（需要 Comparable 或 Comparator）。HashMap 是 Map 之王：桶数组 + 链表，链表长度达到 8 时转红黑树。

Set<String> set = new HashSet<>();
set.add("mysql");
set.add("redis");
set.add("mysql");            // 重复元素被忽略
set.size();                    // 2

Map<String, Integer> map = new HashMap<>();
map.put("java", 1);
map.put("go", 2);
map.get("java");               // 1
map.getOrDefault("rust", 0);   // 0
map.containsKey("go");
map.forEach((k, v) -> System.out.println(k + "=" + v));

// 遍历 Map
for (var e : map.entrySet()) {
    System.out.println(e.getKey() + ": " + e.getValue());
}

排序与泛型

// 泛型保证类型安全
List<Integer> nums = new ArrayList<>();
nums.add(3); nums.add(1); nums.add(2);
Collections.sort(nums);                 // 自然序
nums.sort(Comparator.reverseOrder());   // 降序

// 按字段排序（Comparator 链）
List<User> users = new ArrayList<>();
users.sort(Comparator.comparing(User::getName)
                     .thenComparing(User::getId));

// Comparable：类自带排序规则
class User implements Comparable<User> {
    Long id; String name;
    public int compareTo(User o) { return id.compareTo(o.id); }
}

使用菱形操作符 <> 省略重复的类型参数；新代码不要用裸类型（不带泛型的 List），否则丢失编译期类型安全。