Java 泛型精讲:从 Stream 源码说起

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 下编译运行验证(含"预期编译失败"的反例)。


目录

  1. 怎么读这篇
  2. 泛型是什么
  3. 泛型方法与类型推断
  4. [通配符与 PECS](#通配符与 PECS "#3-%E9%80%9A%E9%85%8D%E7%AC%A6%E4%B8%8E-pecs")
  5. 类型边界与递归泛型
  6. 类型擦除
  7. [裸类型与 unchecked](#裸类型与 unchecked "#6-%E8%A3%B8%E7%B1%BB%E5%9E%8B%E4%B8%8E-unchecked")
  8. 综合精读
  9. 心法与陷阱
  10. 总结速查表

0. 怎么读这篇

你将带走四样东西:

  1. 泛型的完整知识体系:类型参数、泛型方法、类型推断、通配符与 PECS、类型边界、递归泛型、擦除与桥接、裸类型;
  2. 每个概念对应的真实源码签名------以后在任何框架源码里遇到泛型都不怵;
  3. 一套"签名阅读术":把 <R> Stream<R> map(Function<? super T, ? extends R> mapper) 这样的签名逐词拆开读的能力;
  4. 五条泛型设计心法(第 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>...)

三个信息:

  1. <T> 是类型参数声明 ------Stream 自己不知道装什么,用的人指定;
  2. Stream<String> 与 Stream<Integer> 是不同的类型------给 T 赋不同值,得到不同"型号";
  3. 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)

拆两层:

  1. 类型参数边界 :U extends Comparable<? super U>------U 必须"可比较";
  2. 通配符边界 :比较的却是 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)。

编译器做两件事:

  1. 编译期 :按标签严格检查(List<String> 里 add(42) 直接报错);
  2. 生成字节码时 :把泛型参数擦成它的上界 (没写边界就是 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 的做法值得抄:

  1. 对外 API 严格泛型 :Stream<T>、collect(Collector<? super T, A, R>) 没有一处裸类型------用户全程受编译器保护;
  2. 对内实现小范围破例 :裸类型圈在两个私有字段 上,unchecked 强转圈在一个方法的 return 上;
  3. 破例处必留注解+注释 :@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 源码提炼)

  1. PECS 军规 :生产者 ? extends、消费者 ? super------map 的 Function<? super T, ? extends R> 是范本;
  2. 输出用类型参数、输入兼容用通配符 :<R> Stream<R>(输出 R 由方法定),? super T(输入接受整个家族);
  3. 链式返回自身用 F-bounded :BaseStream<T, S extends BaseStream<T, S>>------让接口方法返回 S;
  4. 无关的类型参数用 ? 藏起来 :Collector<T, ?, List<T>>------不暴露实现细节;
  5. 破例圈在最小范围 :裸类型/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") 圈住它。

相关推荐
掘金挖土18 分钟前
前端手摸手跑路之 AI 应用开发(十二)
前端·后端
程序员cxuan19 分钟前
GPT-6.2 Astra 发布了,但口碑崩了。。。
人工智能·后端·程序员
象牙塔五六七20 分钟前
Java 函数式编程精讲:从 Stream 源码说起 —— 用真实源码学懂函数式思维
后端
字节跳动数据库34 分钟前
火山引擎缓存数据库:如何构建超大规模缓存集群的无感弹性能力
数据库·人工智能·后端
IT枫斗者枫哥35 分钟前
Java 异步导出只测最终行数,为什么下载时仍会少一行?
java·后端
用户78506119579736 分钟前
不会前端,我靠 AI 和 Python 做了一个 4K 壁纸站
后端
噜噜学上位机37 分钟前
什么是多态?
后端
站大爷IP40 分钟前
Python的类方法把我坑惨了,原来@classmethod和@staticmethod的区别这么大
后端
Gopher_HBo1 小时前
StartCPUProfile 秒返回,是谁把 cpu.pprof 写满的?
后端