Java 泛型精讲:从 Stream 源码说起 ------ 用真实签名学懂泛型
读 Stream 源码时最容易被劝退的不是流水线、不是并行,而是满屏的泛型签名:
java<R> Stream<R> map(Function<? super T, ? extends R> mapper) abstract class AbstractPipeline<E_IN, E_OUT, S extends BaseStream<E_OUT, S>> public static <T, K, D, A, M extends Map<K, D>> Collector<T, ?, M> groupingBy(...)本文是本系列第三篇(前两篇:《Java Stream 从入门到深入》、《Java Stream 实现原理:JDK 21 源码解析》),换一个角度:以 Stream 源码里的真实泛型签名为教材,系统讲透 Java 泛型 。读完你不仅能看懂上面三行,还能明白 JDK 为什么非要这么写------每个
?、每个extends都有非它不可的理由。版本基线:本文基于 JDK 21(LTS) 。源码引用来自
%JAVA_HOME%/lib/src.zip(java.base/java/util/stream/与java.util),全部代码 demo 在 JDK 21 下编译运行验证(含"预期编译失败"的反例)。
目录
- 怎么读这篇
- 泛型是什么
- 泛型方法与类型推断
- [通配符与 PECS](#通配符与 PECS "#3-%E9%80%9A%E9%85%8D%E7%AC%A6%E4%B8%8E-pecs")
- 类型边界与递归泛型
- 类型擦除
- [裸类型与 unchecked](#裸类型与 unchecked "#6-%E8%A3%B8%E7%B1%BB%E5%9E%8B%E4%B8%8E-unchecked")
- 综合精读
- 心法与陷阱
- 总结速查表
0. 怎么读这篇
你将带走四样东西:
- 泛型的完整知识体系:类型参数、泛型方法、类型推断、通配符与 PECS、类型边界、递归泛型、擦除与桥接、裸类型;
- 每个概念对应的真实源码签名------以后在任何框架源码里遇到泛型都不怵;
- 一套"签名阅读术":把
<R> Stream<R> map(Function<? super T, ? extends R> mapper)这样的签名逐词拆开读的能力; - 五条泛型设计心法(第 8 章),写自己的 API 时用得上。
前置知识:Java 基础(类/接口/继承、多态、集合的基本使用)。不需要读过前两篇------本文用到的 Stream 知识会就地讲解;但读过《从入门到深入》的读者会更有"原来如此"的感觉。
讲解约定(与前两篇一致):
- 每个概念四步走:① 现象 (源码里遇到的签名)→ ② 白话原理 (先用人话讲清)→ ③ 求证 (真实源码/逐行注解)→ ④ 实测(编译运行给你看,包括编译失败的反例);
- 每章结尾本章一句话;⚠️ 标易错点,💡 标设计动机;
- demo 均可复制运行;标注"预期编译失败"的代码是故意写错的,用来观察编译器的拒绝理由------那正是理解规则的最好材料。
本章一句话:带着"签名怎么读"的问题上路,每个泛型概念都从 Stream 源码的真实现场出发。
1. 泛型是什么
1.1 现象:源码第一行就"看不懂"
打开 Stream.java,第一句声明就带着两个泛型机关:
java
// ------ 摘自 Stream.java ------
public interface Stream<T> extends BaseStream<T, Stream<T>> {
<T> 是什么?BaseStream<T, Stream<T>> 里为什么 Stream<T> 出现在自己的 extends 后面?------这是本文要拆解的第一个签名。先从"为什么需要泛型"讲起。
1.2 没有泛型的年代:Object 方案的两个问题
Java 1.5(2004 年)之前没有泛型。想写"能装任何东西的容器",只能用 Object:
java
// 没有泛型的写法(Java 1.4 风格)
List list = new ArrayList();
list.add("hello");
list.add(42); // ① 编译器不拦:什么都往里装
String s = (String) list.get(0); // ② 取出必须强转:啰嗦
String s2 = (String) list.get(1); // ③ 运行时 ClassCastException!
// ④ 装错了,编译期毫无察觉,线上才炸
两个问题:啰嗦 (到处强转)和不安全 (类型错误编译期发现不了,运行期才炸)。泛型就是为解决这两个问题而生的------让"类型"也变成可以传递的参数。
1.3 白话原理:类型参数就是"类型的变量"
你已经熟悉"方法的参数是值的变量":
java
int max(int a, int b) // a、b 是"值"的变量,调用时传 3、5
泛型把同样的思想用到类型上:
java
class Box<T> // T 是"类型"的变量,使用时传 String、Integer
Box<String> b = ...; // 给 T"赋值" String
类比 :方法参数是"这次算哪两个数",类型参数是"这次装哪一类东西"。Box<String> 读作"一个 Box,它的 T 被指定为 String"------就像把模具上的占位符换成了具体型号。
1.4 逐词读 Stream
回到开头的声明:
java
public interface Stream<T> extends BaseStream<T, Stream<T>> {
// │ │ │
// │ │ └─ 第二个参数:S 被指定为 Stream<T>(自己!)
// │ └─ 继承 BaseStream,第一个参数传 T(原样传下去)
// └─ 声明类型参数 T:使用时才确定(Stream<String>、Stream<Integer>...)
三个信息:
<T>是类型参数声明 ------Stream自己不知道装什么,用的人指定;Stream<String>与Stream<Integer>是不同的类型------给 T 赋不同值,得到不同"型号";extends BaseStream<T, Stream<T>>:把 T 原样传给父接口,第二个参数传"我自己这个型号"(第 4 章讲为什么这么写------这是泛型里最"绕"也最优雅的设计之一)。
顺带认识 Optional<T>(java.util.Optional.java)------最简单的泛型类标本:
java
// ------ 摘自 Optional.java ------
public final class Optional<T> { ... }
// Optional<Student> = "可能装着一个 Student 的盒子",T 就是盒中物的类型
1.5 类型参数的命名惯例
JDK 源码的类型参数名不是随便起的,有约定俗成的含义(读懂命名 = 先懂一半语义):
| 名字 | 含义 | Stream 源码实例 |
|---|---|---|
T |
Type,通用类型 | Stream<T>、Collector<T, A, R> |
E |
Element,元素 | Sink<E_OUT> 的元素 |
K / V |
Key / Value | groupingBy 的分组键 K |
R |
Result,结果/返回 | <R> Stream<R> map(...) 的输出类型 |
A |
Accumulator,累加容器 | Collector<T, A, R> 的中间容器 |
S |
自身类型(Self) | BaseStream<T, S> |
N |
Number | Collectors.summingInt 附近 |
1.6 不变性:Stream 不是 Stream
一个初学者必踩的坑。直觉上"Integer 是 Number 的子类,Stream 应该能当 Stream 用"------错:
java
// 预期编译失败(Demo A,JDK 21 实测报错:incompatible types)
Stream<Number> bad = Stream.of(1, 2, 3); // Stream<Integer> 不能赋给 Stream<Number>
List<Number> nums = new ArrayList<Integer>(); // 同样不行
为什么泛型故意"这么死板"? 这叫不变性(invariance)。反证法最清楚------如果允许:
java
List<Integer> ints = new ArrayList<>();
List<Number> nums = ints; // 假装允许
nums.add(3.14); // 按 nums 的类型,加 Double 完全合法
Integer x = ints.get(0); // 但 ints 里混进了 Double → 运行时爆炸
Java 的数组 恰恰犯过这个错(数组是协变的:Integer[] 能赋给 Number[]),结果是运行期的 ArrayStoreException。泛型吸取了数组的教训:宁可编译期严格,不要运行期惊喜。
💡 那"想让 Stream 能塞进 Stream 的参数"怎么办?------通配符(第 3 章)。不变性是原则,通配符是受控的例外。
本章一句话 :泛型 = 类型的变量(<T> 声明、Stream<T> 赋值);不同赋值是不同类型;不变性是刻意设计------防住数组曾经的运行期事故。
2. 泛型方法与类型推断
2.1 现象:map 签名里的 R 是哪来的
Stream.java 中 map 的接口声明:
java
// ------ 摘自 Stream.java ------
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
对比 Stream<T> 的 <T>(类级参数):map 的 <R> 写在方法返回值前面 ------这是方法级类型参数 。每个方法可以有自己的类型参数,而且每次调用可以不同:
java
Stream<Student> students = ...;
Stream<String> names = students.map(Student::getName); // 这次 R = String
Stream<Integer> ages = students.map(Student::getAge); // 这次 R = Integer
2.2 白话原理:类级 vs 方法级
类比 :类级参数像工厂的注册产品型号 (这条流水线装什么,开工前定死);方法级参数像某台机器的临时型号(这台转换机输出什么,每次加工时定)。
Stream<T> 说"这条流里流的是 T";map 的 <R> 说"这一次 转换输出的是 R"。所以同一条 Stream<Student>,map 一次出 Stream<String>、map 一次出 Stream<Integer>------R 是每调一次、重新确定一次的。
2.3 类型推断:编译器怎么知道 R 是什么
你写 map 时从没写过 R:
java
List<String> names = Stream.of(1, 2, 3).map(String::valueOf).collect(Collectors.toList());
R 是谁?编译器推断出来的 。推断的依据就是 mapper 的返回类型------String::valueOf 的返回类型是 String,所以 R = String,map 返回 Stream<String>,collect(toList()) 得到 List<String>,赋给 List<String> 正好。
实测(JDK 21):
java
// Demo C(编译运行通过)
List<String> names = Stream.of(1, 2, 3).map(String::valueOf).collect(Collectors.toList());
// 运行输出:[1, 2, 3];编译期 R 被推断为 String
推断链路值得走一遍(这就是 javac 每次在幕后做的事):
javascript
map(String::valueOf) 的目标类型 Function<? super Integer, ? extends R>
String::valueOf 返回 String
→ ? extends R 要容纳 String → R 推断为 String(最小满足)
→ map 返回 Stream<String>
→ collect(Collectors.toList()) 里 T 推断为 String → List<String>
2.4 什么时候要"自己报型号":类型见证
推断不是万能的。两种情况编译器猜不出(或猜错),你要显式指定方法级类型参数 ------术语叫类型见证(type witness):
情况一:目标类型信息不足。 比如 mapMulti 的 lambda 不返回值(是 Consumer 风格),R 推不出来,必须手写:
java
// Demo D(JDK 21 实测通过)------ 这正是《从入门到深入》12.4 的写法!
List<Integer> lens = words.stream().<Integer>mapMulti((w, down) -> down.accept(w.length()))
.collect(Collectors.toList());
// └─ 类型见证:手动告诉编译器 R = Integer
回看姊妹篇 12.4 那个当时"照抄就行"的 <Integer>mapMulti,现在你知道它是在给方法级类型参数显式赋值。
情况二:显式更清晰/避免歧义。 Stream.<String>of("a", "b")、Collections.<String>emptyList() 都是同类写法。
源码里的真实用例 ------DistinctOps.java 去重的串行实现(源码篇 8.4 见过):
java
// ------ 摘自 DistinctOps.java(节选)------
= ReduceOps.<T, LinkedHashSet<T>>makeRef(LinkedHashSet::new, LinkedHashSet::add, ...);
// └─ 类型见证:显式告诉编译器 makeRef 的两个类型参数
// (参数是构造器引用,推断链太长,JDK 直接手写型号)
💡 规律:方法引用、构造器引用、裸 lambda 让推断线索变少时,类型见证就派上用场 。看到
<X, Y>method(...)这种写法,不要慌------那只是"手动填型号"。
2.5 静态方法也有类型参数
Collectors.toList() 的签名(源码篇 7.5 用过它,现在读它的泛型):
java
// ------ 摘自 Collectors.java ------
public static <T> Collector<T, ?, List<T>> toList() {
三个看点:static 方法照样可以声明 <T>(静态方法不属于任何实例,所以不能用类级的 T ,必须自己声明);返回 Collector<T, ?, List<T>> 里的 ? 是通配符(第 3、7 章拆解);调用 Collectors.toList() 时 T 同样靠推断(collect 的目标类型给出线索)。
本章一句话 :方法级类型参数 <R> 每次调用重新确定,多数时候由编译器从 lambda/方法引用推断;推不出来时用类型见证 <Integer>method(...) 手动报型号------源码里 ReduceOps.<T, LinkedHashSet<T>>makeRef 就是实战。
3. 通配符与 PECS
3.1 现象:签名里满屏的 ? super / ? extends
再看 map 的完整签名(本文的"镇文之宝",值得裱起来):
java
<R> Stream<R> map(Function<? super T, ? extends R> mapper)
如果让你设计,可能写成 map(Function<T, R> mapper)------为什么 JDK 偏偏写 ? super T、? extends R?
3.2 白话原理:通配符是"范围承诺"
先建立直觉(记法:? extends 上界 是"至多 这个类型档次",? super 下界 是"至少能当这个类型用"):
| 写法 | 白话 | 能赋什么进去 |
|---|---|---|
List<? extends Number> |
"装某种 Number 及其子类的列表"(具体哪种不知道) | List<Integer>、List<Double>...(只读安全) |
List<? super Integer> |
"能当 Integer 的容器用的列表" | List<Integer>、List<Number>、List<Object>(只写安全) |
List<Number> |
"精确就是 Number 的列表" | 只有 List<Number> |
关键区别:List<Integer> 不能 赋给 List<Number>(1.6 的不变性),但能 赋给 List<? extends Number>------通配符把"精确类型"松绑成"类型范围",换来了受控的灵活性。
3.3 PECS 口诀:生产者 extends,消费者 super
这是泛型最著名的一条军规(出自《Effective Java》):
PECS:Producer Extends, Consumer Super。 如果参数是生产者 (你从它读 出 T),用
? extends T; 如果参数是消费者 (你往它写 进 T),用? super T。
为什么?用赋值规则推一遍:
- 生产者(读) :你要保证"读出来的一定能当 T 用"------
? extends T承诺"里面装的至多是 T 的档次",读出来向上转型安全; - 消费者(写) :你要保证"写进去的它都收"------
? super T承诺"它至少能装 T",写 T 或 T 的子类都安全。
3.4 精读 map:一个参数里的双重 PECS
java
<R> Stream<R> map(Function<? super T, ? extends R> mapper)
// │ │
// │ └─ R 的生产者:mapper 吐出的东西要能当 R 用 → ? extends R
// └─ T 的消费者:mapper 要吃下流里的每个 T → ? super T
逐词翻译:"给我一个函数:它能吃下任何 T(或 T 的超类),吐出的东西至少是 R 的档次。" 两个通配符各司其职,一个管输入兼容、一个管输出兼容。
实测 (Demo B,JDK 21)------? super T 的威力:
java
Stream<String> s = Stream.of("a", "bb");
Function<Object, CharSequence> wide = Object::toString; // 入参 Object(比 String 宽)、返回 CharSequence
Stream<CharSequence> r = s.map(wide); // ✅ 编译通过
// 运行输出:[a, bb]
Function<Object, CharSequence> 的入参是 Object (String 的超类)------正因为签名写的是 ? super String,这个"更宽的函数"才能被接受。如果签名是严格的 Function<String, R>,它反而编译不过。
反例(预期编译失败):
java
Function<Integer, CharSequence> f = ...;
s.map(f); // ❌ 编译错误:Integer 不是 String 的超类------? super String 拒收
3.5 mapMulti:连"消费者的消费者"都用 ? super
Stream.java 里 mapMulti 的签名(源码签名里 PECS 密度最高的一行):
java
// ------ 摘自 Stream.java ------
<R> Stream<R> mapMulti(BiConsumer<? super T, ? super Consumer<R>> mapper);
// │ │ │
// │ │ └─ R 的消费者 Consumer<R> 本身也被 ? super 包着
// │ └─ T 的消费者
// └─ 双输入消费者
读法:"给我一个双参数消费者 :第一个参数能吃下 T;第二个参数是一个'收 R 的接收器',且这个接收器的超类版本 也能用。"为什么 Consumer<R> 还要套 ? super?因为下游接收器的具体实现类型(比如内部的 Sink<R>)与 Consumer<R> 并不精确相同------? super Consumer<R> 把"接收器的实现差异"也吸收了。
3.6 collect:Collector<? super T, A, R>
终结操作 collect 的签名(源码篇 7.2 精读过实现,现在读类型):
java
// ------ 摘自 Stream.java ------
<R, A> R collect(Collector<? super T, A, R> collector);
// │
// └─ 收集器是元素的消费者 → ? super T(PECS 的消费者侧)
收集器要吃 元素,所以用 ? super T。这带来一个实用的灵活性:Stream<Student> 可以用为 Stream<Person> 设计的收集器(Student 是 Person 的子类,Collector<? super Student, ...> 吃得下)------这就是"协变收集"的来源。
本章一句话 :通配符把"精确类型"松成"类型范围";PECS 铁律------读(生产)用 ? extends、写(消费)用 ? super;map 的 Function<? super T, ? extends R> 是一个参数里的双重 PECS。
4. 类型边界与递归泛型
4.1 现象:类型参数还能"提要求"
AbstractPipeline 的类声明(源码篇 2.3 的主角,现在只看它的泛型):
java
// ------ 摘自 AbstractPipeline.java ------
abstract class AbstractPipeline<E_IN, E_OUT, S extends BaseStream<E_OUT, S>>
三个类型参数,第三个还带着 extends ...------类型边界(bounded type parameter):"S 不是随便什么类型,必须满足这个条件。"
4.2 白话原理:边界 = 类型参数的准入条件
java
<T extends Comparable<T>> // T 必须"能和自己比较"
<T extends Number> // T 必须是 Number 体系
类比 :方法参数可以带校验("年龄必须 > 0"),类型参数也可以带约束("必须是 Comparable")。有了边界,编译器就允许你在泛型代码里调用边界承诺的方法------T extends Comparable<T> 的代码里可以放心调 t.compareTo(other)。
4.3 递归泛型:S extends BaseStream<E_OUT, S> 的读法
BaseStream 的完整声明:
java
// ------ 摘自 BaseStream.java ------
public interface BaseStream<T, S extends BaseStream<T, S>> extends AutoCloseable {
逐词拆这个"蛇咬尾巴"的写法(术语叫 F-bounded polymorphism / 自引用泛型,CRTP):
swift
BaseStream<T, S extends BaseStream<T, S>>
│ │ │
│ │ └─ 第二个参数必须"是它自己"(S 传给 BaseStream 的还是 S)
│ └─ S 必须是 BaseStream 的一种
└─ 声明一个自身类型参数 S
白话翻译:"BaseStream 的第二个参数,是'继承我的那个具体类型',而且必须还是 BaseStream 家族的。 " 于是 Stream<T> 声明时写 implements BaseStream<T, Stream<T>>------把"我自己"作为 S 传回去。
4.4 为什么需要:流式 API 的"返回 this"问题
动机是每个流式 API 都躲不开的一件事:方法要返回"调用者自己的类型"。
BaseStream 里有 sequential()、parallel()、onClose() 等"设置型"方法,理想返回类型是"你手上拿的是 Stream 就还你 Stream,拿的是 IntStream 就还你 IntStream"。接口方法返回 BaseStream 太笨(掉型),返回 Stream 又越权(父接口不认识子类)。解法------把"自己的类型"设计成参数 S:
java
// ------ 摘自 BaseStream.java(方法返回 S!)------
S sequential();
S parallel();
于是 Stream<T> 实现时 S 被指定为 Stream<T>,stream.parallel() 的返回类型自动是 Stream<T>,不用强转。源码篇 12 章答疑里 parallel() 的实现只有一行 sourceStage.parallel = true; return (S) this;------那个 (S) this 强转能成立,靠的就是 S 的边界承诺。
4.5 实测:最小 CRTP 复刻
java
// Demo F(JDK 21 编译运行通过)------ BaseStream<T, S> 的最小翻版
interface Self<S extends Self<S>> { S self(); }
class Impl implements Self<Impl> {
@Override public Impl self() { return this; }
}
// 用法:
Impl impl = new Impl().self(); // 返回 Impl,无需强转!
// 运行输出:Impl
没有这个技巧时,self() 只能返回 Self,调用方还得 (Impl) obj.self() 强转------F-bounded 的全部价值就是"把强转从调用方挪到声明方,且只挪一次"。
4.6 同款设计:AbstractTask
并行任务的骨架(源码篇 9.3)用了一模一样的手法:
java
// ------ 摘自 AbstractTask.java ------
abstract class AbstractTask<P_IN, P_OUT, R,
K extends AbstractTask<P_IN, P_OUT, R, K>>
extends CountedCompleter<R> {
protected abstract K makeChild(Spliterator<P_IN> spliterator);
// └─ 返回 K:子类实现返回自己的类型(ReduceTask 返回 ReduceTask)
}
makeChild 返回 K------子类 ReduceTask 实现时 K 就是 ReduceTask,于是 makeChild 的调用方拿到的直接是 ReduceTask,父子任务链全程无强转。
4.7 通配符边界 vs 类型参数边界:Comparable<? super U> 的精妙
最后一个高阶签名------Comparator.comparing(《从入门到深入》5.2 推荐过它的写法):
java
// ------ 摘自 Comparator.java ------
public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
Function<? super T, ? extends U> keyExtractor)
拆两层:
- 类型参数边界 :
U extends Comparable<? super U>------U 必须"可比较"; - 通配符边界 :比较的却是
Comparable<? super U>而不是Comparable<U>!
为什么不是 Comparable<U>?考虑 class Student extends Person implements Comparable<Person>(学生按"人"的规则比大小)。此时:
U = Student,Student 不是Comparable<Student>------若要求Comparable<U>则编译不过;- 但 Student 是
Comparable<Person>,而 Person 是? super Student------Comparable<? super U>正好收留。
一句话:Comparable<? super U> 让"按父类规则比较的子类"也能用------通配符边界比类型参数边界更宽,是刻意留的兼容口。
本章一句话 :边界 T extends X 给类型参数提准入条件;自引用 S extends BaseStream<T, S>(F-bounded)解决流式 API"返回 this"问题;Comparable<? super U> 展示了通配符边界比类型参数边界更宽的兼容智慧。
5. 类型擦除
5.1 现象:运行时根本没有 Stream
问一个问题:Stream<String> 和 Stream<Integer> 在运行时是两个类吗?
java
Stream<String> a = Stream.of("x");
Stream<Integer> b = Stream.of(1);
System.out.println(a.getClass() == b.getClass()); // true!同一个 Class
因为泛型是编译期 的机制,运行期会被"擦掉"------术语叫类型擦除(type erasure)。这一章看擦除的证据、机制和代价。
5.2 白话原理:编译期的便签,编译完就撕
类比 :给一批货箱贴"内装衣物/内装食品"的标签,检查时(编译期)按标签严格核对;但装船时(运行期)标签全撕掉,箱子里的东西按通用货箱处理(擦成 Object)。
编译器做两件事:
- 编译期 :按标签严格检查(
List<String>里 add(42) 直接报错); - 生成字节码时 :把泛型参数擦成它的上界 (没写边界就是 Object),并在必要的地方自动补强转。
所以 list.get(0) 在字节码里其实是 (String) list.get(0)------你没写强转,编译器替你写了。这也解释了 1.2 的对比:泛型不是取消了强转,而是把强转交给编译器,并提前到编译期检查。
5.3 证据一:桥接方法(实测)
擦除带来一个新问题:子类"缩小参数类型"的重写,在擦除后签名不一致了。看实测(Demo Erasure,JDK 21):
java
abstract class Chained<T, E_OUT> {
void accept(T t) { ... } // 擦除后:accept(Object)
}
class MySink extends Chained<String, Integer> {
@Override void accept(String s) { ... } // 擦除后:accept(String)------签名对不上了!
}
编译器怎么办?偷偷生成一个"桥接方法",把 accept(Object) 转发给 accept(String)。用反射实测编译后的 MySink:
dart
方法: void MySink.accept(java.lang.String) ← 你写的真身
方法: void MySink.accept(java.lang.Object) ← 编译器生成的桥接(转发到真身)
两个 accept 并存,父类视角调 accept(Object)、子类逻辑跑 accept(String)------多态在擦除后依然成立,靠的就是这座"桥"。
💡 这也解释了源码篇 3.3 里
Sink.ChainedReference<T, E_OUT>的accept(P_OUT u)为什么"Override 得上"------表面签名一致,底下还有一层桥接方法在默默工作。
5.4 证据二:擦除的三个"做不到"
因为 T 在运行期不存在,以下写法编译不过(实测):
java
List<String>[] arr = new List<String>[1]; // ❌ 编译错误:创建通用数组(generic array creation)
// if (obj instanceof List<String>) // ❌ 非法:instanceof 不能带泛型参数
// T t = new T(); // ❌ 非法:不能 new 一个类型参数
实测输出 (javac Bad.java):
arduino
错误: 创建通用数组的数组
public class Bad { List<String>[] arr = new List<String>[1]; }
为什么 generic array 危险? 数组是协变+运行期记住元素类型的(5.5 讲的数组教训),而泛型擦除后不认识 String------两者根本机制冲突,所以 Java 直接禁止。(Stream 的 toArray(String[]::new) 用 IntFunction<E_OUT[]> 让你传"造数组的工厂",正是绕开这个限制的标准手法------源码篇 11 站的 toArray 细节。)
5.5 为什么当年选擦除:向后兼容
一个自然的问题:为什么不像 C# 那样"泛型保留到运行期"(reified generics)?
因为 Java 5 要兼容 Java 4 的世界 :老的字节码、老的类库、老的 JVM 都不认识泛型。擦除让带泛型的新代码和不带泛型的老代码无缝互操作 ------List<String> 擦成 List,老代码照常调用。代价就是本章的种种限制。这是"兼容性压倒完美性"的典型工程决策(和你团队"多终端新老版本兼容"的原则一脉相承)。
本章一句话:泛型是编译期便签,编译后擦成上界(Object)并自动补强转;桥接方法让重写在擦除后依然成立(实测双 accept);不能 new T\[\]/instanceof T 皆因擦除;选擦除是为了 Java 5 对 Java 4 的兼容。
6. 裸类型与 unchecked
6.1 现象:源码里居然有 @SuppressWarnings("rawtypes")
《实现原理》篇 2.3 读过这两个字段,现在用泛型的眼光重看:
java
// ------ 摘自 AbstractPipeline.java ------
@SuppressWarnings("rawtypes")
private final AbstractPipeline sourceStage; // ← 裸类型!没写 <E_IN, E_OUT, S>
@SuppressWarnings("rawtypes")
private final AbstractPipeline previousStage; // ← 同上
教科书说"不要用裸类型",为什么 JDK 自己用?------因为教科书还有一句:规则的例外要用在受控的最小范围。这一章讲裸类型、unchecked 警告,以及"什么时候可以破例"。
6.2 白话原理:裸类型 = 撕掉标签的类
List<String>:贴了标签的箱子(编译期严格检查);List(裸类型):撕了标签的箱子(什么都能装、取出要强转、编译器只给警告);List<Object>:不是 裸类型------它是"明确装 Object 的标签",检查依然严格(List和List<Object>语义不同,但都危险)。
实测 (Demo Raw,javac -Xlint:unchecked):
java
List raw = new ArrayList(); // 裸类型
raw.add("a");
List<String> s = raw; // 赋值时编译器发出警告
编译输出(原文):
csharp
警告: [unchecked] 对作为原始类型List的成员add(E)的调用未检查
"未检查(unchecked)"就是编译器的免责声明:"你要用裸类型,我拦不住,出事别找我。"
6.3 精读:AbstractPipeline 为什么必须用裸类型
回到那两个字段。问题的本质:流水线是一条"异构链表"------每个节点的类型参数都不一样:
vbnet
Head<String, String> ← 起点:入=String 出=String
↓ previousStage
FilterOp<String, String> ← filter:入=String 出=String
↓ previousStage
MapOp<String, Integer> ← map:入=String 出=Integer ← 出入类型变了!
↓ previousStage
...
MapOp<String, Integer> 的上游是 FilterOp<String, String>------两个节点的类型参数根本不同 。如果字段写成 AbstractPipeline<E_IN, E_OUT, S> previousStage,泛型要求每个节点类型一致,表达不了"任意段的异构链"。这是泛型真正力所不及的地方:链表节点之间的类型关系("你的输出是我的输入")超出了泛型的表达能力。
于是 JDK 的选择是:字段用裸类型 + @SuppressWarnings("rawtypes") 静音,方法边界处用 unchecked 强转衔接 。看 wrapSink 的返回(源码篇 3.4 精读过这个方法):
java
// ------ 摘自 AbstractPipeline.java(wrapSink 结尾)------
return (Sink<P_IN>) sink; // ← unchecked 强转:编译器说"我无法验证,你担保"
sink 一路被 opWrapSink 包壳,类型从 Sink<E_OUT> 变换到 Sink<P_IN>(链头的输入类型)------这中间的类型变换逻辑只有 JDK 自己懂 ,编译器无法跟踪,所以用强转 + @SuppressWarnings("unchecked") 收尾。
6.4 两种警告的区别
| 注解 | 静音的警告 | 典型场景 |
|---|---|---|
@SuppressWarnings("rawtypes") |
使用裸类型 List(没写类型参数) |
AbstractPipeline 的异构链表字段 |
@SuppressWarnings("unchecked") |
未检查的强转/赋值(擦除相关) | (Sink<P_IN>) sink、裸类型赋给 List<String> |
6.5 心法:破例要破在"最小的笼子"里
JDK 的做法值得抄:
- 对外 API 严格泛型 :
Stream<T>、collect(Collector<? super T, A, R>)没有一处裸类型------用户全程受编译器保护; - 对内实现小范围破例 :裸类型圈在两个私有字段 上,unchecked 强转圈在一个方法的 return 上;
- 破例处必留注解+注释 :
@SuppressWarnings标明"我知道在做什么",注释解释为什么。
自己写代码时的判断题:你能不能向编译器证明类型安全? 能→用泛型写满;不能→先把设计改到能,实在不能(如异构容器、反射框架)→缩小范围、加注解、写注释。
本章一句话:裸类型是撕标签的箱子(警告=编译器免责);AbstractPipeline 的异构链表是泛型真正表达不了的场景,JDK 用"裸类型字段+unchecked 强转"受控破例------对外严、对内破、破在最小处。
7. 综合精读
前六章的武器全部亮出来,拆解两个最复杂的实战签名。
7.1 Collector<T, A, R>:三个参数的分工
java
// ------ 摘自 Collector.java ------
public interface Collector<T, A, R> {
| 参数 | 含义 | toList() 里的对应 |
|---|---|---|
T |
流进来的元素类型 | Student |
A |
中间容器(累加器)类型 | ArrayList<Student> |
R |
最终结果类型 | List<Student> |
为什么 A 和 R 要分开?因为中间容器 ≠ 最终结果 ------toUnmodifiableList() 的 A 是 ArrayList、R 是不可变 List(finisher 做转换);joining() 的 A 是 StringBuilder、R 是 String。四件套(源码篇 7.5)的泛型形态:
java
// ------ 摘自 Collectors.java(CollectorImpl,record)------
record CollectorImpl<T, A, R>(Supplier<A> supplier, // 造 A
BiConsumer<A, T> accumulator, // A 吃 T
BinaryOperator<A> combiner, // 两个 A 并一个 A
Function<A, R> finisher, // A 变 R
Set<Characteristics> characteristics) {
四个函数的类型把数据流向画得明明白白:T → A → R ,合并在 A 层做(BinaryOperator<A>)。每个参数都有出处,没有一个是凑数的。
7.2 toList() 的签名:? 是干什么的
java
// ------ 摘自 Collectors.java ------
public static <T> Collector<T, ?, List<T>> toList()
// │
// └─ 无限定通配符:A 被"藏"起来了
返回类型的中间参数是 ? 而不是 ArrayList<T>------这叫通配符隐藏实现细节 :调用者只关心"收集出 List",不必知道也不应依赖内部容器是 ArrayList。若写成 Collector<T, ArrayList<T>, List<T>>,就把实现焊死在签名上,以后换容器就成了破坏性变更。? 的白话:"中间是什么容器,无可奉告,反正给你 List。"
7.3 groupingBy:五参数签名逐词拆
全系列最复杂的签名(Collectors.java,三参数重载):
java
// ------ 摘自 Collectors.java ------
public static <T, K, D, A, M extends Map<K, D>>
Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier,
Supplier<M> mapFactory,
Collector<? super T, A, D> downstream)
五个类型参数、三处通配符、一处边界。逐个拆:
| 记号 | 含义 | 调用时实际是 |
|---|---|---|
T |
流元素 | Student |
K |
分组键 | Gender |
D |
下游收集的最终类型 | Long(counting) |
A |
下游收集的中间容器 | 被 ? 隐藏 |
M extends Map<K, D> |
结果 Map 的具体类型(带边界!) | TreeMap<Gender, Long> |
三处通配符各有理由:
Function<? super T, ? extends K> classifier------分类器吃 T(PECS 消费者侧)、吐 K(生产者侧);Supplier<M> mapFactory------M 有extends Map<K, D>边界,所以TreeMap::new能当Supplier<TreeMap<Gender, Long>>用;Collector<? super T, A, D> downstream------下游收集器也是元素的消费者(PECS)。
一次真实调用的推断过程(《从入门到深入》8.3 的例子):
java
Map<Gender, Long> count = students.stream()
.collect(Collectors.groupingBy(Student::getGender, Collectors.counting()));
swift
students.stream() → Stream<Student>,T = Student
Student::getGender → 返回 Gender,K 推断为 Gender
Collectors.counting() → Collector<Object, ?, Long>,D = Long
(注意 counting 是 Collector<Object,...>,
由 ? super T = ? super Student 收下------PECS 的馈赠!)
返回类型 M 默认 HashMap → Map<Gender, Long>
(Map<K,D> = Map<Gender, Long> 正好接住)✓
counting() 声明的元素类型其实是 Object(它不挑元素)------? super Student 让这个"什么都能数"的收集器直接可用。PECS 不是炫技,是让 counting() 这类通用收集器到处复用的基础设施。
7.4 BinaryOperator:类型别名式的简化
reduce 的归约函数签名用了一个"特化"接口:
java
// ------ 摘自 BinaryOperator.java ------
public interface BinaryOperator<T> extends BiFunction<T, T, T> {
// │ │ │
// │ │ └─ 返回 T
// │ └─ 第二个参数 T
// └─ 第一个参数 T
BiFunction<T, T, T> 三个参数全是 T------每次写它都得重复三遍 T。BinaryOperator<T> 把它"起了个短名":同一类型的二元运算 (加法、取最大、字符串拼接都是)。这不是新能力,是可读性的类型别名------读签名时看到 BinaryOperator 就知道"入参出参同型"。
本章一句话 :Collector<T, A, R> 画出 T→A→R 的数据流;toList() 的 ? 隐藏实现容器;groupingBy 的五参数签名是 PECS+边界+推断的集大成者------counting() 复用的秘密就在 ? super T。
8. 心法与陷阱
8.1 五条设计心法(从 Stream 源码提炼)
- PECS 军规 :生产者
? extends、消费者? super------map 的Function<? super T, ? extends R>是范本; - 输出用类型参数、输入兼容用通配符 :
<R> Stream<R>(输出 R 由方法定),? super T(输入接受整个家族); - 链式返回自身用 F-bounded :
BaseStream<T, S extends BaseStream<T, S>>------让接口方法返回 S; - 无关的类型参数用
?藏起来 :Collector<T, ?, List<T>>------不暴露实现细节; - 破例圈在最小范围 :裸类型/unchecked 只用在表达不了的场景(异构链表),配合
@SuppressWarnings+ 注释,对外 API 保持严格。
8.2 为什么有 IntStream:泛型不能用基本类型
一个常被忽略的语言限制:泛型的类型参数只能是引用类型 ------Stream<int> 不存在,List<double> 不存在。想装 int 只能装它的包装类 Integer(自动装箱)。
于是原始类型流的特化家族登场(《从入门到深入》第 9 章):IntStream、IntConsumer、ToIntFunction、Sink.OfInt......它们存在的首要原因是语言限制 (泛型玩不了 int),性能(免装箱)是顺带的红利。《实现原理》篇 3.3 的 accept(int) 特化入口,根源也在这里。
8.3 高频编译错误对照表
| 编译错误(关键词) | 原因 | 修复 |
|---|---|---|
incompatible types: Stream<Integer> cannot be converted to Stream<Number> |
泛型不变性 | 改用通配符 Stream<? extends Number>(只读)或改设计 |
required: Comparable<...> found: Student |
类型参数边界不满足 | 让 Student 实现 Comparable<? super Student> |
创建通用数组(generic array creation) |
擦除+数组机制冲突 | 用 T[] 工厂(toArray(String[]::new))或集合 |
name clash: both methods have same erasure |
两个方法擦除后签名相同 | 重命名或改参数类型 |
missing type arguments for raw type |
裸类型使用 | 补上 <T>;历史代码加 @SuppressWarnings |
method does not override or implement a method from a supertype |
泛型重写签名不匹配 | 检查类型参数是否与父类一致(桥接方法救不了语义错位) |
8.4 面试速答 FAQ
| 问题 | 一句话答案 |
|---|---|
| 泛型擦除后还有类型信息吗? | 类上的泛型签名保留在 class 文件元数据(TypeToken 能读),但运行期不可用于 instanceof/new;方法体里的 T 擦成上界 |
? extends 和 ? super 区别? |
extends 上界(只读安全,生产者)、super 下界(只写安全,消费者);口诀 PECS |
| 为什么泛型不支持基本类型? | 类型参数必须是引用类型(擦除目标是 Object/上界),int 没有对象形态 → 装箱或特化(IntStream) |
| 桥接方法是什么? | 编译器为"擦除后签名不一致的重写"生成的转发方法(实测 MySink 两个 accept) |
Stream<Integer> 能赋给 Stream<Number> 吗? |
不能(不变性);数组的协变教训就是 ArrayStoreException |
| 泛型方法的类型参数何时要手写? | 推断线索不足(构造器引用、无返回值 lambda)时用类型见证 <Integer>mapMulti(...) |
| 为什么 Collector 有 3 个类型参数? | T 元素、A 中间容器、R 结果;A 常被 ? 隐藏 |
本章一句话:五条心法(PECS/输出参数化/F-bounded/隐藏实现/最小破例)+ 一张错误对照表 + 七个 FAQ,泛型的日常难题基本全覆盖。
9. 总结速查表
概念 → Stream 源码实例
| 泛型概念 | Stream 源码实例 | 章节 |
|---|---|---|
类型参数 <T> |
interface Stream<T>、Optional<T> |
1 |
| 不变性 | Stream<Integer> 不能赋给 Stream<Number> |
1 |
泛型方法 <R> |
<R> Stream<R> map(...) |
2 |
| 类型推断 | map(String::valueOf) → Stream<String> |
2 |
| 类型见证 | <Integer>mapMulti(...)、ReduceOps.<T, LinkedHashSet<T>>makeRef |
2 |
| 通配符上界/下界 | Function<? super T, ? extends R> |
3 |
| PECS | map/collect/mapMulti 的每个 ? |
3 |
无限定通配符 ? |
Collector<T, ?, List<T>> |
7 |
| 类型参数边界 | U extends Comparable<? super U> |
4 |
| 递归泛型(F-bounded) | BaseStream<T, S extends BaseStream<T, S>>、AbstractTask<..., K extends AbstractTask<...>> |
4 |
| 类型擦除 | Stream<String>.getClass() == Stream<Integer>.getClass() |
5 |
| 桥接方法 | Chained.accept(Object) → accept(P_OUT) |
5 |
| 泛型数组限制 | toArray(String[]::new) 的存在理由 |
5 |
| 裸类型 + rawtypes | AbstractPipeline sourceStage 字段 |
6 |
| unchecked 强转 | (Sink<P_IN>) sink |
6 |
| 类型别名 | BinaryOperator<T> extends BiFunction<T,T,T> |
7 |
术语对照
| 英文 | 中文 | 章节 |
|---|---|---|
| Generic / Type Parameter | 泛型 / 类型参数 | 1 |
| Invariance / Covariance | 不变性 / 协变 | 1 |
| Type Inference | 类型推断 | 2 |
| Type Witness | 类型见证 | 2 |
| Wildcard / Bounded Wildcard | 通配符 / 有界通配符 | 3 |
| PECS (Producer Extends, Consumer Super) | 生产者 extends、消费者 super | 3 |
| Bounded Type Parameter | 有界类型参数 | 4 |
| F-bounded Polymorphism / CRTP | 自引用泛型 / 奇异递归模板 | 4 |
| Type Erasure | 类型擦除 | 5 |
| Bridge Method | 桥接方法 | 5 |
| Raw Type / Unchecked | 裸类型 / 未检查 | 6 |
| Reified Generics | 具体化泛型(C# 路线) | 5 |
记忆口诀
"类型即变量,赋值见型号;推断省手写,见证补线索;读用 extends,写用 super(PECS);边界提要求,递归返回己;擦除编译后,桥接补多态;裸型圈最小,泛型写满安全。"
一句话总结
泛型 = 类型层面的参数化 :<T> 声明变量、Stream<T> 赋值、推断省手写、通配符管兼容(PECS)、边界提要求、F-bounded 解决返回 this、擦除换兼容、桥接补多态。Stream 源码把这八件事全用了一遍------看懂了 <R> Stream<R> map(Function<? super T, ? extends R> mapper),就看懂了 Java 泛型的半壁江山。
动手实验清单(三个实验,各 10 分钟)
实验一:亲眼看桥接方法 (对应第 5 章) 把本文 Demo Erasure 的两个类编译后执行 javap -p MySink(或用反射打印 getDeclaredMethods()),观察 accept(java.lang.String) 与 accept(java.lang.Object) 并存;再删掉 @Override 的 accept(String) 看桥接消失。
实验二:亲眼看 PECS 被拒 (对应第 3 章) 把 Demo B 里的 Function<Object, CharSequence> 改成 Function<Integer, CharSequence> 再编译------记录编译器的报错原文;然后把 map 调用改成 .map((Function<String, ? extends CharSequence>) f) 观察强转如何绕过检查(以及为什么不该这么写)。
实验三:亲眼看 unchecked 警告 (对应第 6 章) 用 javac -Xlint:unchecked Raw.java 观察警告原文;把裸类型 List 改成 List<Object> 看警告消失(理解裸类型 ≠ List<Object>);再写一个方法刻意 (List<String>) raw 强转,练习用 @SuppressWarnings("unchecked") 圈住它。