1. 八节串线

暗线一句话：这章学的是"怎么装一堆对象，还装得聪明"——从能用（ArrayList）到会选型（List/Set/Map 三口诀）到会加工（Stream 一行流）。

2. 概念速查 14 条

1. 集合只能装对象——int 要变 Integer（6.1 自动装箱）。
2. Collection 是接口，不能 new；Collections 是工具类，全 static。
3. List：有序（存取一致）、带下标、可重复——ArrayList 默认首选。
4. Set：不重复、无下标、顺序不保证——HashSet 查最快。
5. Map：键唯一、值可重复，双列结构，不归 Collection 管。
6. remove 歧义：remove(int) 按下标，remove(Object) 按内容；List<Integer> 删值要 remove(Integer.valueOf(1))。
7. contains 底层：挨个调 equals——自定义类不重写就比地址。
8. 去重两道关卡：hashCode 定位桶 → equals 验明正身；重写 equals 必搭伴重写 hashCode。
9. 遍历中删元素：只用 it.remove() 或普通 for 倒着删；增强 for / 正着删都出事（modCount 账本机制）。
10. Map 遍历：keySet / values / entrySet 三姿势，entrySet 效率最好。
11. getOrDefault 计数器：map.put(k, map.getOrDefault(k, 0) + 1)。
12. Arrays.asList 定长：能 set 不能 add/remove；要增删包一层 new ArrayList<>(...)。
13. binarySearch 前提：必须先 sort，乱序结果错且不报错。
14. Stream 三段式：中间操作（备菜，返回新流）+ 终结操作（开火，一次性）；惰性求值——没终结操作不执行。

3. 代码模板 4 段

模板一：ArrayList 基本功

List<String> list = new ArrayList<>();
list.add("甲");                          // 增
list.add(1, "乙");                       // 插队
String s = list.get(0);                  // 取
list.set(0, "丙");                       // 改
list.remove(0);                          // 删（按下标）
for (String x : list) System.out.println(x);   // 遍历

模板二：自定义类去重（4.5 收网款）

class Student {
    String name;
    // 构造方法省略……

    @Override
    public boolean equals(Object o) { /* 按内容比 */ }
    @Override
    public int hashCode() { /* 与 equals 搭伴生成 */ }
}

Set<Student> set = new HashSet<>();   // 同内容只留一份

模板三：Map 计数器

Map<String, Integer> counter = new HashMap<>();
for (String w : words) {
    counter.put(w, counter.getOrDefault(w, 0) + 1);
}
// 遍历三姿势
for (Map.Entry<String, Integer> e : counter.entrySet()) {
    System.out.println(e.getKey() + " 出现 " + e.getValue() + " 次");
}

模板四：Stream 一行流

List<Integer> result = scores.stream()
        .filter(s -> s >= 80)          // 中间操作，可继续链
        .sorted()
        .collect(Collectors.toList()); // 终结操作，装回新集合

4. 八大名坑回顾

1. List<Integer> 里 remove(1) 删的是下标 1 不是值 1。
2. 增强 for 遍历中 list.remove() → ConcurrentModificationException。
3. 自定义类不重写 equals+hashCode → Set 去重失灵、Map 当键失灵。
4. Arrays.asList 定长，add/remove 炸 UnsupportedOperationException。
5. binarySearch 不先 sort → 结果错误还不报错。
6. Stream 流一次性，终结后复用炸 IllegalStateException。
7. 只写中间操作不写终结操作 → 一行不执行（惰性）。
8. new ArrayList<int>() 编译报错——泛型只能装引用类型。

5. 跨章连线

• 面向对象 → 集合：没有封装和多态就没有统一 Collection 合同；泛型 <String> 是 4.4 类型安全的延伸。
• 异常 → 集合：ConcurrentModificationException、UnsupportedOperationException、ClassCastException 全是 5.2 收容所常客。
• Java API → 集合：自动装箱（6.1）、equals/hashCode（4.5→7.5）、Lambda（4.7→7.8）、工具类套路（6.3→7.7）。
• 数据结构视角：ArrayList 底层数组、LinkedList 链表、HashSet 哈希表——7.3/7.5 已经埋了理论钩子，后续数据结构专题会正式展开。

6. 毕业大题：单词计数器（综合全章）

import java.util.*;
import java.util.stream.*;

public class Final07 {
    public static void main(String[] args) {
        String text = "java is fun and java is powerful and java everywhere";

        // ① 切词（6.8 split）→ 统计每个单词出现次数（Map 计数器）
        String[] words = text.split(" ");
        Map<String, Integer> counter = new HashMap<>();
        for (String w : words) {
            counter.put(w, counter.getOrDefault(w, 0) + 1);
        }

        // ② 去重看看有几种单词（Set）
        Set<String> distinct = new HashSet<>(Arrays.asList(words));
        System.out.println("共 " + distinct.size() + " 种单词");

        // ③ Stream 挑出出现 ≥2 次的单词，按次数降序打印（7.8）
        counter.entrySet().stream()
                .filter(e -> e.getValue() >= 2)
                .sorted((a, b) -> b.getValue() - a.getValue())
                .forEach(e -> System.out.println(e.getKey() + ": " + e.getValue()));
    }
}
// 输出：java: 3   and: 2   is: 2

7. 下一步学什么

• ☑ 第八章 泛型开课 ✅ —— 8.1 泛型基础 点此复习：7.1 里"会认"的 <String> 正式讲透——编译期安检 + 自己写泛型类 Box\<T>。

相关笔记

• 第四章 面向对象（下）/4.7 函数式编程：Lambda——Stream 的发动机
• 第五章 异常/5.6 本章小结：异常章小结——本章三个异常都从那来
• 第六章 Java API/6.9 本章小结：API 章小结——装箱与工具类套路在本章上岗
• 2.7 数组：集合的"前身"，本章第一笔与最后一笔旧账都收在它头上