10万字总结Java8到21新特性详解

╰+哭是因爲堅強的太久メ 2024-04-21 19:07 38阅读 0赞

#### 文章目录 ####

*  Java 8 新特性—概述
 *   *  JEP 126：Lambda 表达式
     *  JEP 126：函数式接口
     *  JEP 179：方法引用
     *  JEP 150：接口的默认方法
     *  JEP 107：Stream API
     *  Optional 类
     *  JEP 170：新的日期时间 API
     *  JEP 120：重复注解
     *  Base64 编码解码
     *  JEP 104：类型注解
     *  JEP 101：类型推断优化
     *  JEP 174：Nashorn JavaScript 引擎
     *  JEP 122：移除Permgen
 *  Java 8 新特性—Lambda 表达式
 *   *  什么是 Lambda 表达式
     *  常见用法
     *   *  无参数，无返回值
         *  单参数，无返回值
         *  多参数，有返回值
     *  Lambda 简写依据
 *  Java 8 新特性—函数式接口
 *   *  什么是函数式接口
     *  自定义函数式接口
     *  常用函数式接口
     *   *  Consumer 接口
         *  Function 接口
         *  Supplier 接口
         *  Predicate 接口
         *  其他函数式接口
 *  Java 8 新特性—方法引用和构造器引用
 *   *  什么是方法引用
     *  三种方法引用类型
     *   *  引用静态方法
         *  引用对象的实例方法
         *  引用类型的任意对象的实例方法
     *  方法引用的前提条件
     *  方法引用的终极神器
     *  构造器引用
     *  数组引用
 *  Java 8 新特性— 利用 Optional 解决NullPointerException
 *   *  引言
     *  Optional 是什么
     *  API 介绍
     *   *  \*\*构造 Optional 对象\*\*
         *  \*\*检查是否有值\*\*
         *  获取值
         *  类型转换
         *  过滤
     *  实战应用
 *  Java 8 新特性—日期时间 API
 *   *  为什么 Java 8 要重新设计日期时间 API
     *  Instant：时间点
     *  LocalDate ：本地日期
     *   *  创建 LocalDate
         *  日期计算
         *  获取日期信息
         *  修改日期
     *  Period：LocalDate 的距离
     *  LocalTime 本地时间
     *   *  创建 LocalTime
         *  时间计算
         *  获取时间信息
         *  修改时间
     *  LocalDateTime 本地日期时间
     *  ZonedDateTime 带时区的日期时间
     *   *  什么是时区
         *  ZonedDateTime 的使用方法
 *  Java 8 新特性—日期时间格式化
 *   *  DateTimeFormatter
     *   *  \*\*创建 DateTimeFormatter\*\*
         *  格式转换
         *   *  \*\*将日期时间对象转换为字符串\*\*
             *  \*\*将字符串解析为日期时间对象\*\*
     *  DateTimeFormatterBuilder
 *  Java 8 新特性—深入理解 CompletableFuture
 *   *  Future 的局限性
     *  什么是 CompletableFuture
     *  CompletableFuture 的核心 API
     *   *  构建异步操作
         *  获取结果
         *  结果、异常处理
         *  结果转换
         *  结果消费
         *  结果组合
         *  任务交互
     *  CompletableFuture 的任务编排
     *  CompletableFuture API 总结
     *  参考文章
 *  Java 8 新特性—重复注解@Repeatable
 *   *  Java 8 之前如何使用重复注解
     *  Java 8 重复注解 @Repeatable
     *   *  如何使用重复注解
 *  Java 8 新特性—接口默认方法和静态方法
 *   *  接口默认方法
     *  接口静态方法
 *  Java 8 新特性—Stream API 对元素流进行函数式操作
 *   *  什么是 Stream API
     *  为什么要用 Stream API
     *  Stream 操作三部曲
     *   *  \*\*创建 Stream\*\*
         *  \*\*中间操作\*\*
         *  \*\*终端操作\*\*
     *  Stream API 介绍
     *   *  中间操作
         *   *  筛选与切片
             *  映射
             *  排序
         *  终端操作
         *   *  匹配与查找
             *  归约
             *  收集
     *  示例
     *   *  案例使用的基础数据
         *  01、获取一班中学生的平均年龄
         *  02、找出所有班级中的学生中的最高分数
         *  03、获取所有班级中的学生的数量
         *  04、获取所有学生中的男女数量
         *  05、统计每个班级的男女数量
         *  06、找出所有班级中成绩前10名的学生
         *  07、找出每个班级成绩前 3 名的学生
 *  Java 8 新特性—类型注解
 *   *  类型注解可以用在哪些地方？
     *  类型注解有什么作用？
 *  Java 8 新特性—类型推断优化
 *   *  理解泛型
     *  Java 7 类型推断优化
     *  Java 8 类型推断优化
     *   *  \*\*与 Lambda 表达式和方法引用的协同\*\*
         *  Stream API 中的应用
 *  Java 8 新特性—全新的、标准的 Base64 API
 *   *  引言
     *  Base64 的核心原理
     *  Java 8 中的Base64 API
     *  Base64示例
     *   *  基本 Base64 编码
         *  URL 和文件名安全 Base64 编码
         *  MIME 类型 Base64 编码
 *  Java 9 新特性—概述
 *   *  \*\*JEP 261: 模块系统\*\*
     *  \*\*JEP 269: 集合工厂方法\*\*
     *  J\*\*EP 222\*\*：Jshell
     *  JEP 213：接口支持私有方法
     *  Stream API 增强
     *  Optional 的增强
     *  改进 try-with-resources
     *  JEP 102：Process API
     *  JEP 264：平台日志 API 和 服务
     *  JEP 266: 反应式流（Reactive Streams）
     *  JEP 224: HTML5 Javadoc
     *  JEP 238: 多版本兼容 JAR 文件
     *  JEP 277：\*\*改进的弃用注解 @Deprecated\*\*
     *  JEP213：\*\*改进钻石操作符(Diamond Operator)\*\*
     *  增强 CompletableFuture
 *  Java 9 新特性—模块化
 *   *  什么是模块化
     *  为什么需要模块化
     *  怎么用模块化
 *  Java 9 新特性—REPL 工具：JSheel 命令
 *   *  什么是 JShell
     *  为什么需要使用 \*\*JShell\*\*
     *  使用 \*\*JShell\*\*
     *  JShell 的主要命令
 *  Java 9 新特性—接口支持私有方法
 *  Java 9 新特性—String 底层存储结构变更
 *  Java 9 新特性—Optional 的增强
 *   *  or()
     *  ifPresentOrElse()
     *  stream()
 *  Java 9 新特性—try-with-resources的升级
 *   *  Java 7 之前，资源需要手动关闭
     *  Java 7 中的 try-with-resources
     *  Java 9 对 try-with-resources 的改进
 *  Java 9 新特性—Stream API的增强
 *   *  新增 ofNullable()
     *  重载 iterate()
     *  新增 dropWhile() 和 takeWhile()
     *   *  dropWhile()
         *  takeWhile()
 *  Java 9 新特性—新增只读集合和工厂方法
 *   *  Java 8 创建不可变集合
     *  Java 9 创建不可变集合
 *  Java 9 新特性—改进CompletableFuture
 *   *  \*\*新的工厂方法\*\*
     *  \*\*支持超时和延迟执行\*\*
     *   *  支持超时
         *  支持延迟执行
     *  \*\*支持子类化\*\*
 *  Java 10 新特性—概述
 *   *  JEP 286：局部变量类型推断
     *  JEP 304：统一的垃圾回收接口
     *  JEP 307：并行全垃圾回收器 G1
     *  JEP 310：应用程序类数据共享
     *  JEP 312：线程-局部变量管控
     *  JEP 313：移除 Native-Header 自动生成工具
     *  JEP 314：额外的 Unicode 语言标签扩展
     *  JEP 316：备用存储装置上的堆分配
     *  JEP 317：基于 Java 的 实验性 JIT 编译器
     *  JEP 319：根证书认证
     *  JEP 322：基于时间的版本发布模式
     *  新增 API
 *  Java 10 新特性—局部变量类型推断
 *   *  产生背景
     *  好处
     *  使用场景
     *   *  局部变量声明
         *  \*\*初始化集合和泛型表达式\*\*
         *  遍历操作
         *  在try-with-resources语句中
     *  不适用场景
     *  注意事项
 *  Java 10 新特性—不可变集合的增强
 *  Java 11 新特性—概述
 *   *  \*\*JEP 181: 基于嵌套的访问控制\*\*
     *  新增\*\*String \*\*API
     *  \*\*JEP 321\*\*：全新的 HTTP 客户端 API
     *  JEP 323：\*\*局部变量类型推断\*\*的升级
     *  \*\*JEP 318：Epsilon—低开销垃圾回收器\*\*
     *  ZGC：可伸缩低延迟垃圾收集器
     *  \*\*JEP 335：废弃 Nashorn JavaScript 引擎\*\*
     *  增加 Files API
     *  Optional API 增强
     *  \*\*JEP 328\*\*：飞行记录器（\*\*Flight Recorder\*\*）
     *  JEP 330：\*\*运行单文件源码程序\*\*
     *  \*\*JEP 320\*\*：删除 Java EE 和 corba 模块
 *  Java 11 新特性—新增 String API
 *  Java 11 新特性—新增 Files API
 *  Java 11 新特性—Optional API 的增强
 *  Java 11 新特性—局部变量类型推断的增强
 *  Java 11 新特性—全新的 HTTP 客户端 API
 *   *  为什么要提供全新的 HTTP 客户端
     *  核心类介绍
     *   *  HttpClient
         *  HttpRequest
         *  HttpResponse
     *  示例
     *   *  同步发送
         *  异步发送
 *  Java 12 新特性—概述
 *   *  JEP 189：\*\*Shenandoah 垃圾收集器\*\*（\*\*预览特性\*\*）
     *  JEP 325：\*\*Switch 表达式\*\*（\*\*预览特性\*\*）
     *  JEP 334：\*\*JVM 常量 API\*\*
     *  JEP 230：\*\*微基准测试套件（JMH）的支持\*\*
     *  新增 String API
     *  新增 Files API
     *  新增 NumberFormat API
     *  新增 Collectors API
     *  \*\*JEP 340\*\*：移除多余ARM64实现
     *  \*\*JEP 341：\*\*默认CDS归档
     *  \*\*JEP 344：\*\*G1的可中断 mixed GC
 *  Java 12 新特性—Switch 表达式
 *  Java 12 新特性—新增 String API
 *  Java 12 新特性—新增 Files API
 *  Java 12 新特性—新增NumberFormat对复杂数字的格式化
 *  Java 12 新特性—新增 Collectors API
 *  Java 13 新特性—概述
 *   *  \*\*JEP 354\*\*：增强 Switch 表达式（第二次预览）
     *  JEP 355：文本块（预览特性）
     *  JEP 353：重构 Socket API
     *  \*\*JEP 350：动态 CDS\*\*
     *  \*\*JEP 351\*\*：增强 ZGC 释放未使用内存
 *  Java 13 新特性—Switch 表达式扩展
 *  Java 13 新特性—文本块
 *  Java 14 概述—概述
 *   *  JEP 361：Switch 表达式（正式特性）
     *  JEP 368：增强文本块（第二次预览）
     *  JEP 359：Records (预览)
     *  JEP 305：模式匹配的 instanceof（预览）
     *  JEP 358：改进 NullPointerExceptions 提示信息
     *  JEP 343：打包工具（孵化）
     *  \*\*JEP 345\*\*：NUMA-Aware 内存分配
     *  \*\*JEP 349\*\*：\*\*JFR Event Streaming\*\*
     *  JEP 364：macOS 上的 ZGC（实验性）
     *  \*\*JEP 365：Windows 上的 ZGC（实验性）\*\*
     *  \*\*JEP 366：弃用 ParallelScavenge + SerialOld GC 组合\*\*
     *  \*\*JEP 367：删除 Pack200 工具和 API\*\*
     *  JEP 363： 删除 CMS 垃圾收集器
     *  JEP 370：外部存储器访问 API（孵化器版）
 *  Java 14 新特性—模式匹配的 instanceof
 *  Java 14 新特性—新增 Record 类型
 *   *  为什么要引入 Record
     *  什么是 Record
 *  Java 14 新特性—改进 NullPointerExceptions提示信息
 *  Java 15 新特性—概述
 *   *  JEP 339：\*\*Edwards-Curve 数字签名算法 (EdDSA)\*\*
     *  JEP 360：密封的类和接口（预览）
     *  JEP 371：隐藏类 Hidden Classes
     *  JEP 372：\*\*移除 Nashorn JavaScript 引擎\*\*
     *  JEP 373：重新实现 DatagramSocket API
     *  JEP 374：禁用偏向锁定
     *  JEP 375：模式匹配的 instanceof（第二次预览）
     *  JEP 377：ZGC—可伸缩低延迟垃圾收集器（正式特性）
     *  JEP 378：文本块（正式特性）
     *  \*\*JEP 379\*\*：Shenandoah—低暂停时间垃圾收集器（正式特性）
     *  JEP 381：\*\*移除 Solaris 和 SPARC 支持\*\*
     *  JEP 383：外部存储器访问 API （二次孵化器版）
     *  JEP 384： Record (第二次预览)
     *  JEP 385： 废除 RMI 激活
 *  Java 15 新特性—密封的类和接口
 *   *  引言
     *  密封类
     *   *  什么是密封类
         *  示例代码
 *  Java 15 新特性—Hidden Classes（隐藏类）
 *   *  什么是隐藏类
     *  怎么使用隐藏类
 *  Java 16 新特性—概述
 *   *  \*\*JEP 338\*\*：向量 API（孵化器）
     *  JEP 347：启用 C++14 语言特性
     *  JEP 357：将JDK的源代码库从Mercurial迁移到Git
     *  JEP 369：将JDK的源代码库托管到GitHub
     *  JEP 376：ZGC 并发线程处理
     *  JEP 380：Unix-Domain 套接字通道
     *  JEP 386：AlpineLinux 移植
     *  JEP 387：弹性元空间
     *  JEP 388：Windows/AArch64 移植
     *  JEP 389：外部函数与内存 API（孵化器）
     *  JEP 390：对基于值的类发出警告
     *  JEP 392：打包工具（正式版）
     *  JEP 393：外部存储器访问 API（第三次孵化）
     *  JEP 394：instanceof 模式匹配（正式特性）
     *  JEP 395：Records (正式特性)
     *  JEP 396：默认强封装 JDK 内部元素
     *  JEP 397：密封类（第二预览）

## Java 8 新特性—概述 ##

> Java 8 是Java历史上一个重大的版本更新，发布于2014年3月18日。

![img][]

### JEP 126：Lambda 表达式 ###

Lambda 表达式是 Java 8 新特性中最重要且最显著的一个，为 Java 增加了函数式编程的能力，使得代码变得更加简洁和易读。Lambda 表达式主要用于简化匿名内部类的实现。

Lambda 表达式的基本语法：

(parameters) -> expression 或 (parameters) -> {
       
         statements; }

*  `parameters` ：是 Lambda表达式的参数列表，可以为空或包含一个或多个参数。
 *  `->` ：是 Lambda 操作符，用于将参数和 Lambda 主体分开。
 *  `expression` ：是 Lambda 表达式的返回值，或者在主体中执行的单一表达式。
 *  `{ statements; }` ：是 Lambda 主体，包含了一系列语句，如果需要执行多个操作，就需要使用这种形式。

它具有如下几个特点：

1.  **无需声明类型**：Lambda 表达式不需要声明参数类型，编译器可以自动推断参数类型。
2.  **可选的参数圆括**号：当只有一个参数时，可以省略圆括号。但是当参数个数大于一个时，圆括号是必需的。空括号用于表示空参数集。
3.  **可选的大括号**：当 Lambda 表达式的主体只包含一个表达式时，可以省略大括号。当表达式需要包含多个语句时，需要使用大括号。
4.  **可选的返回关键字**：当 Lambda 表达式主体只有一个表达式，且该表达式会自动返回结果时，可以省略 return 关键字。

### JEP 126：函数式接口 ###

Java 8 引入函数式接口的主要目的是支持函数式编程范式，也就是 Lambda 表达式。在函数式编程语言中，函数被当做一等公民对待，Lambda 表达式的类型是函数，它可以像其他数据类型一样进行传递、赋值和操作。但是在 Java 中，“**一切皆对象**”是不可违背的宗旨，所以 Lambda 表达式是对象，而不是函数，他们必须要依附于一类特别的对象类型：函数式接口。所以函数式接口是与Lambda表达式紧密相连的，它为Java添加了一种新的抽象层次，**允许将方法作为一等公民对待**。

函数式接口具有两个特点：

1.  **只包含一个抽象方法**：函数式接口只能有一个抽象方法，但可以包含多个默认方法或静态方法。
2.  **用**`@FunctionalInterface`**注解标记**：该注解不强制，但通常会使用它来标记该接口为函数式接口。这样做可以让编译器检查接口是否符合函数式接口的定义，以避免不必要的错误。

一般来说函数式接口有两个最主要的用途：

1.  与 Lambda表达式一起使用，为Java带来更加函数式的编程风格。
2.  用于实现简单的函数策略或行为，如回调、事件处理等。

### JEP 179：方法引用 ###

为了提升 Java 编程语言的表达力和可读性，特别是在配合 Lambda 表达式和函数式编程风格，Java 8 引入方法引用。

方法引用实际上是一个简化版的 Lambda 表达式，它允许我们以更简洁的方式引用方法。它有如下几种类型：

1.  静态方法引用：使用`类名::静态方法名`的形式。
    
     *  例如，`String::valueOf` 相当于 `x -> String.valueOf(x)`。
2.  实例方法引用（对象的实例方法）：使用 `实例对象::实例方法名`的形式。
    
     *  例如，假设有一个 `String` 对象 `myString`，那么 `myString::length` 相当于 `() -> myString.length()`。
3.  特定类型的任意对象的实例方法引用：使用 `类名::实例方法名`。
    
     *  例如，`String::length` 相当于 `str -> str.length()`。这里不是调用特定对象的 `length` 方法，而是用于任意的 `String` 对象。
4.  构造器引用：使用`类名::new`

*  例如，`ArrayList::new` 相当于 `() -> new ArrayList<>()`。

### JEP 150：接口的默认方法 ###

在 Java 8 之前，接口中可以申明方法和变量的，只不过变量必须是 public、static、final 的，方法必须是 public、abstract的。我们知道接口的设计是一项巨大的工作，因为如果我们需要在接口中新增一个方法，需要对它的所有实现类都进行修改，如果它的实现类比较少还可以接受，如果实现类比较多则工作量就比较大了。

为了解决这个问题，Java 8 引入了默认方法，默认方法允许在接口中添加具有默认实现的方法，它使得接口可以包含方法的实现，而不仅仅是抽象方法的定义。

默认方法是接口中带有 `default` 关键字的非抽象方法。这种方法可以有自己的实现，而不需要子类去覆盖它。

默认方法允许我们向接口添加新方法而不破坏现有的实现。它解决了在 Java 8 之前，向接口添加新方法意味着所有实现该接口的类都必须修改的问题。

### JEP 107：Stream API ###

为了解决 Java 8 之前版本中集合操作的一些限制和不足，提高数据处理的效率和代码的简洁性，Java 8 引入 Stream API，它的引入标志着 Java 对集合操作迎来了的一种全新的处理方式，它在处理集合类时提供了一种更高效、声明式的方法。

`Stream API`的核心思想是将数据处理操作以函数式的方式链式连接，以便于执行各种操作，如过滤、映射、排序、归约等，而无需显式编写传统的循环代码。

下面是 `Stream API` 的一些重要概念和操作：

1.  `Stream`（流）：`Stream`是 Java 8 中处理集合的关键抽象概念，它是数据渠道，用于操作数据源所生成的元素序列。这些数据源可以来自集合（`Collection`）、数组、`I/O`操作等等。它具有如下几个特点：
    
    1.  `Stream` 不会存储数据。
    2.  `Stream` 不会改变源数据对象，它返回一个持有结果的新的 `Stream`。
    3.  `Stream` 操作是延迟执行的，这就意味着他们要等到需要结果的时候才会去执行。
2.  **中间操作**：这些操作允许您在 `Stream` 上执行一系列的数据处理。常见的中间操作有 `filter`（过滤）、`map`（映射）、`distinct`（去重）、`sorted`（排序）、`limit`（截断）、`skip`（跳过）等。这些操作返回的仍然是一个 Stream。
3.  **终端操作**：终端操作是对流进行最终处理的操作。当调用终端操作时，流将被消费，不能再进行进一步的中间操作。常见的终端操作包括 `forEach`（遍历元素）、`collect`（将元素收集到集合中）、`reduce`（归约操作，如求和、求最大值）、`count`（计数）等。
4.  **惰性求值**：Stream 操作是惰性的，只有在调用终端操作时才会执行中间操作。这可以提高性能，因为只处理需要的数据。

### Optional 类 ###

Java 8 引入了 `Optional` 类，这是一个为了解决空指针异常（`NullPointerException`）而设计的容器类。它可以帮助开发者在编程时更优雅地处理可能为 `null` 的情况。

### JEP 170：新的日期时间 API ###

作为 Java 开发者你一定直接或者间接使用过 `java.util.Date` 、`java.util.Calendar`、`java.text.SimpleDateFormat` 这三个类吧，这三个类是 Java 用于处理日期、日历、日期时间格式化的。由于他们存在一些问题，诸如：

1.  线程不安全：
    
    1.  `java.util.Date` 和 `java.util.Calendar` 线程不安全，这就导致我们在多线程环境使用需要额外注意。
    2.  `java.text.SimpleDateFormat` 也是线程不安全的，这可能导致性能问题和日期格式化错误。而且它的模式字符串容易出错，且不够直观。
2.  **可变性**：`java.util.Date`类是可变的，这意味着我们可以随时修改它，如果一不小心就会导致数据不一致问题。
3.  **时区处理困难**：Java 8 版本以前的日期 API 在时区处理上存在问题，例如时区转换和夏令时处理不够灵活和准确。而且时区信息在 `Date` 对象中存储不明确，这使得正确处理时区变得复杂。
4.  设计不佳：
    
    1.  日期和日期格式化分布在多个包中。
    2.  `java.util.Date` 的默认日期，年竟然是从 1900 开始，月从 1 开始，日从 1 开始，没有统一性。而且 `java.util.Date` 类也缺少直接操作日期的相关方法。
    3.  日期和时间处理通常需要大量的样板代码，使得代码变得冗长和难以维护。

基于上述原因，Java 8 重新设计了日期时间 API，以提供更好的性能、可读性和可用性，同时解决了这些问题，使得在 Java 中处理日期和时间变得更加方便和可靠。相比 Java 8 之前的版本，Java 8 版本的日期时间 API 具有如下几个优点：

1.  **不可变性（Immutability）**：Java 8的日期时间类（如`LocalDate`、`LocalTime`和`LocalDateTime`）都是不可变的，一旦创建就不能被修改。这确保了**线程安全**，避免了并发问题。
2.  **清晰的API设计**：Java 8 的日期时间 API 采用了更清晰、更一致的设计，相比于以前版本的 `Date` 和 `Calendar` 更易于理解和使用。而且它们还提供了丰富的方法来执行日期和时间的各种操作，如加减、比较、格式化等。
3.  **本地化支持**：Java 8 的日期时间 API 支持本地化，可以轻松处理不同地区和语言的日期和时间格式。它们能够自动适应不同的时区和夏令时规则。
4.  **新的时区处理**：Java 8引入了 `ZoneId` 和 `ZoneOffset` 等新的时区类，使时区处理更加精确和灵活。这有助于解决以前版本中时区处理的问题。
5.  **新的格式化API**：Java 8引入了 `DateTimeFormatter` 类，用于格式化和解析日期和时间，支持自定义格式和本地化。这提供了更强大和灵活的格式化选项。
6.  **更好的性能**：Java 8 的日期时间API 比以前的API 性能更佳。

### JEP 120：重复注解 ###

在 Java 8 之前的版本中，对于一个特定的类型，一个注解在同一个声明上只能使用一次。Java 8 引入了重复注解，它允许对同一个类型的注解在同一声明或类型上多次使用。

工作原理如下：

1.  **定义重复注解**：您需要定义一个注解，并用 `@Repeatable` 元注解标注它。`@Repeatable` 接收一个参数，该参数是一个容器注解，用于存储重复注解的实例。
2.  **定义容器注解**：容器注解定义了一个注解数组，用于存放重复注解的多个实例。这个容器注解也需要具有运行时的保留策略（`@Retention(RetentionPolicy.RUNTIME)`）。

### Base64 编码解码 ###

在 Java 8 之前，我们通常需要依赖于第三方库（如 Apache Commons Codec）或者使用 Java 内部类（如 `sun.misc.BASE64Encoder` 和 `sun.misc.BASE64Decoder`）来处理 Base64 编解码。但是这些内部类并非 Java 官方的一部分，它们的使用并不推荐，因为它们可能会在未来的版本中发生变化，造成兼容性问题。同时使用非官方或内部 API 可能导致安全漏洞或运行时错误，所以 Java 8 引入一个新的 Base64 编解码 API，它处理 Base64 编码和解码的官方、标准化的方法。

Java 8 中的 Base64 API 包含在 `java.util` 包中。它提供了以下三种类型的 Base64 编解码器：

1.  **基本型（Basic）**：用于处理常规的 Base64 编码和解码。它不对输出进行换行处理，适合于在URLs和文件名中使用。
2.  **URL和文件名安全型（URL and Filename Safe）**：输出映射到一组 URL 和文件名安全的字符集。它使用 ‘-’ 和 ‘\_’ 替换标准 Base64 中的 ‘+’ 和 ‘/’ 字符。
3.  **MIME型**：用于处理 MIME 类型的数据（例如，邮件）。它在每行生成 76 个字符后插入一个换行符。

### JEP 104：类型注解 ###

在 Java 8 之前，注解仅限于声明（如类、方法或字段）。这种限制意味着注解的用途在许多编程情景中受到限制，特别是在需要对类型本身（而不仅仅是声明）进行描述时。为了提高注解的能力，Java 8 引入类型注解来增强注解的功能。

该特性扩展了注解的应用范围，允许我们将注解应用于任何使用类型的地方，而不仅仅是声明。包括以下情况：

*  对象创建（如 `new` 表达式）
 *  类型转换和强制类型转换
 *  实现（implements）语句
 *  泛型类型参数（如 `List<@NonNull String>`）

### JEP 101：类型推断优化 ###

在 Java 8 之前，Java 的类型推断主要局限于泛型方法调用的返回类型。这意味着在许多情况下，我们不得不显式指定泛型参数，即使它们可以从上下文中推断出来。这种限制使得代码变得冗长且不够直观，特别是在使用泛型集合和泛型方法时。

为了提高编码效率和可读性，同时简化泛型使用，Java 8 中引入了对类型推断机制的优化，扩大了类型推断的范围，使其能在更多情况下自动推断出类型信息，包括：

1.  **Lambda 表达式中的类型推断**：在使用 Lambda 表达式时，编译器可以根据上下文推断出参数类型，从而减少了在某些情况下编写显式类型的需求。
2.  **泛型方法调用的改进**：在调用泛型方法时，编译器可以更好地推断方法参数、返回类型以及链式调用中间步骤的类型。
3.  **泛型构造器的类型推断**：在创建泛型对象时，编译器能够推断出构造器参数的类型。

### JEP 174：Nashorn JavaScript 引擎 ###

在 Java 8 之前，Java 平台的主要 JavaScript 引擎是 Mozilla 的 Rhino。Rhino 是一个成熟的引擎，但由于其架构和设计年代较早，它在性能和与 Java 的集成方面存在一些限制。随着 JavaScript 在 Web 和服务器端应用中日益重要，需要一个更现代、更高效的 JavaScript 引擎来提供更好的性能和更深度的 Java 集成。因此，Nashorn 引擎被引入作为 Java 平台的一部分。

Nashorn 是一个基于 Java 的 JavaScript 引擎，它完全用 Java 语言编写，并且是 Rhino 的替代品。主要特点：

1.  **基于 JVM 的执行**：Nashorn 是作为 Java 虚拟机的一个原生组件实现的，它直接编译 JavaScript 代码到 Java 字节码。这意味着它可以充分利用 JVM 的性能优化和管理能力。
2.  **高性能**：与 Rhino 相比，Nashorn 提供了显著的性能提升，特别是在执行 JavaScript 代码方面。
3.  **与 Java 的深度集成**：Nashorn 允许 JavaScript 代码和 Java 代码之间有更紧密的交互。开发者可以在 JavaScript 中方便地调用 Java 类库和对象，反之亦然。
4.  **ECMAScript 5.1 支持**：Nashorn 支持 ECMAScript 5.1 规范，为开发者提供了一个符合标准的现代 JavaScript 编程环境。

### JEP 122：移除Permgen ###

在 Java 8 之前，JJVM使用永久代（PermGen）的内存区域来存储类的元数据和方法数据。随着时间的推移，这个设计开始显现出一些问题，特别是在应用程序频繁加载和卸载类的场景中，比如在 Java EE 应用服务器和热部署环境中。

永久代有一个固定的大小限制，当类的数量和大小超过这个限制时，就会抛出 `OutOfMemoryError: PermGen space` 错误。这种设计限制了 Java 的灵活性和可伸缩性。

Java 8 移除永久代并用元空间（Metaspace）的新内存区域来取代它。相比永久代，元空间的具有如下优势：

1.  **基于本地内存**：元空间不在 JVM 的堆内存中，而是直接使用本地内存（操作系统的内存）。这意味着它不再受到 Java 堆大小的限制。
2.  **动态调整大小**：元空间的大小可以根据应用程序的需求动态调整。这减少了内存溢出的风险，并允许应用更高效地管理内存。
3.  **更好的性能**：由于移除了固定大小的限制，元空间可以提供更好的性能，尤其是在大型应用和复杂的部署环境中。

--------------------

## Java 8 新特性—Lambda 表达式 ##

![img][img 1]

### 什么是 Lambda 表达式 ###

Lambda 表达式是在 Java 8 中引入，并且被吹捧为 Java 8 最大的特性。它是函数式编程的的一个重要特性，标志着 Java 向函数式编程迈出了重要的第一步。

它的语法如下：

(parameters) -> expression

或者

(parameters) -> {
       
         statements; }

其中

Java 8 引入 Lambda 表达式的主要作用是简化部分匿名内部类的写法。使用它可以完成用少量的代码实现复杂的功能，极大的简化代码代码量和代码结构。同时，JDK 中也增加了大量的内置函数式接口供我们使用，使得在使用 Lambda 表达式时更加简单、高效。

下面我们就来看它的一些常见用法。

### 常见用法 ###

#### 无参数，无返回值 ####

例如 `Runnable` 接口的 `run()`。

在 Java 8 版本之前的版本，我们一般都是这样用：

new Thread(new Runnable() {
       
        
                @Override
                public void run() {
       
        
                    System.out.println("死磕 Java 就是牛逼...");
                }
            }).start();

从 Java 8 开始，无参数匿名内部类可以简写成如下这种方式：

() -> {
       
        
        执行语句
    }

所以上面代码可以简写成这样的：

new Thread(() -> System.out.println("死磕 Java 就是牛逼...")).start();

#### 单参数，无返回值 ####

只有一个参数，无返回值，如下：

(x) -> System.out.println(x);

在 Java 8 中，有一个函数式接口 Consumer，它定义如下：

@FunctionalInterface
    public interface Consumer<T> {
       
        
    
        void accept(T t);
    }

我们用它来演示下：

Consumer<String> consumer = (String s) -> {
       
        
                System.out.println(s);
            };
            
            consumer.accept("死磕 Java 就是牛...");

是不是比较简便，但是这段代码还不够简便，它还可以进行多次优化，

*  如果 Lambda 主体只有一条语句，则 `{、}` 可以省略

Consumer<String> consumer = (String s) -> System.out.println(s);

*  Lambda 表达式有一个依据：**类型推断机制**。在上下文信息足够的情况下，编译器可以推断出参数表的类型，而不需要显式指名。所以 `(String s)` 可以简写为 `(s)`：

Consumer<String> consumer = (s) -> System.out.println(s);

*  对于只有一个参数的情况，左侧括号可以省略：

Consumer<String> consumer = s -> System.out.println(s);

#### 多参数，有返回值 ####

如 Comparator 接口的 `compare(T o1, T o2)` 方法，在 Java 8 之前，写法如下：

Comparator<Integer> comparator = new Comparator<Integer>() {
       
        
                @Override
                public int compare(Integer o1, Integer o2) {
       
        
                    System.out.println("o1:" + o1);
                    System.out.println("o2:" + o2);
                    return o1.compareTo(o2);
                }
            };
            
            comparator.compare(12,13);

使用 Lambda 表达式后：

Comparator<Integer> comparator = (o1, o2) -> {
       
        
                System.out.println("o1:" + o1);
                System.out.println("o2:" + o2);
                return o1.compareTo(o2);
            };
    
            comparator.compare(12,13);

当然，如果去掉 `System.out.println()`，还可以简写为 `Comparator<Integer> comparator = (o1, o2) -> o1.compareTo(o2);` ，这里是可以省略 return 关键字的。

这里就 Lambda 的简写做一个总结：

1.  **类型推断**：编译器可以根据上下文推断 Lambda 表达式的参数类型，从而可以省略参数类型的声明。
2.  **单一参数**：当 Lambda 表达式只有一个参数时，可以省略参数外的括号。如: `(x) → x * 2` 可以简写为 `x → x * 2` 。
3.  **单表达式**：当 Lambda 表达式只有一行代码时，可以省略大括号和 return 关键字。如 `(x,y) → {return x + y}` 可以简写为 `(x,y) → x + y`。

### Lambda 简写依据 ###

Lambda 简写的依据有两个：

> **1、必须有相应的函数式接口**

所谓函数式接口函数式就是指只包含一个抽象方法的接口，它是在 Java 8 版本中引入的，其主要目的是支持函数式编程，有了函数式接口我们可以将函数作为参数传递、将函数作为返回值返回，同时也为使用 Lambda 表达式提供了支持。

函数式接口具有以下特征：

1.  **只包含一个抽象方法**：函数式接口只能有一个抽象方法，但可以包含多个默认方法或静态方法（Java 8 中有另一个新特性：`default` 关键字）。这个唯一的抽象方法通常用来表示某种功能或操作。
2.  **用**\*\*`@FunctionalInterface`\*\***注解标记**：注解不强制，但通常会使用它来标记该接口为函数式接口。这样做可以让编译器检查接口是否符合函数式接口的定义，以避免不必要的错误。

> **2、类型推断机制**

类型推断机制则是允许编译器根据上下文自动推断 Lambda 表达式的参数类型。这个推断过程包括两个方面：

1.  **目标类型推断**

编译器会根据 Lambda 表达式在赋值、传参等地方的上下文来推断Lambda表达式的目标类型。例如，如果Lambda表达式被赋值给一个接口类型的变量，编译器会根据该接口的抽象方法来推断Lambda表达式的参数类型。

Runnable runnable = () -> System.out.println("死磕 Java 就是牛...");

Lambda表达式被赋值给了 Runnable 类型的变量，所以编译器知道 Lambda 表达式需要没有参数且返回类型为`void`的方法。

1.  **参数类型推断**

如果 Lambda 表达式的参数类型可以从上下文中唯一确定，编译器会自动推断参数的类型。例如：

List<String> skList = Arrays.asList("死磕 Java 并发", "死磕 Netty", "死磕 NIO","死磕 Spring");
    skList.forEach(sk -> System.out.println(sk));

`forEach`方法期望一个参数类型为`Consumer<String>`的函数，编译器可以从 `sk`的类型推断出Lambda表达式的参数类型为`String`。

虽然类型推断机制允许省略Lambda表达式的参数类型，但有时候显式声明参数类型可以增强代码的可读性和处理复杂的泛型情况，这个时候我们还是将参数类型写上会显得更加友好。

--------------------

## Java 8 新特性—函数式接口 ##

在上边 Lambda 表达式 提过，Lambda 能够简化的一个依据就是函数式接口，这篇文章我们就来深入了解函数式接口。

![img][img 2]

### 什么是函数式接口 ###

函数式接口是一个只有一个抽象方法的接口，最开始的时候也叫做 **SAM 类型**的接口（`Single Abstract Method`）。它具有两个特点：

Java 引入函数式接口的主要目的是支持函数式编程范式，也就是 Lambda 表达式。在函数式编程语言中，函数被当做一等公民对待，Lambda 表达式的类型是函数，它可以像其他数据类型一样进行传递、赋值和操作。但是在 Java 中，“**一切皆对象**”是不可违背的宗旨，所以 Lambda 表达式是对象，而不是函数，他们必须要依附于一类特别的对象类型：函数式接口。

> 所以，**从本质上来说 Lambda 表达式就是一个函数式接口的实例**。这就是 Lambda 表达式和函数式接口的关系。简单理解就是只要一个对象时函数式接口的实例，那么该对象就可以用 Lambda 表达式来表示。

### 自定义函数式接口 ###

根据函数式接口的定义和特点，我们可以自定义函数式接口：

@FunctionalInterface
    public interface FunctionInterface {
       
        
    
        /**
         * 抽象方法
         */
        void doSomething();
    
        /**
         * 默认方法
         * @param s
         */
        default void defaultMethod(String s) {
       
        
            System.out.println("默认方法：" + s);
        }
    
        /**
         * 静态方法
         * @param s
         */
        static void staticMethod(String s) {
       
        
            System.out.println("静态方法：" + s);
        }
    }

FunctionInterface 是一个自定义函数式接口，它只包含一个抽象方法 `doSomething()`，还包含一个默认方法 `defaultMethod(String s)` 和一个静态方法 `staticMethod(String s)`，这两个方法都是可选的。

`@FunctionalInterface` 注解是可写可可不写的，但是我们一般都推荐写，写上他可以让编译器检查接口是否符合函数式接口的定义，以避免不必要的错误，比如：

![img][img 3]

上面接口定义了两个抽象方法，它会明确告诉你错误了。

使用如下：

FunctionInterface functionInterface = () -> {
                System.out.println("死磕 Java 就是牛...");
            };
    
            // 调用抽象方法
            functionInterface.doSomething();
            // 调用默认方法
            functionInterface.defaultMethod("死磕 Netty 就是牛...");
            // 调用静态方法
            FunctionInterface.staticMethod("死磕 Java 并发就是牛...");

执行如下：

![img][img 4]

### 常用函数式接口 ###

其实在 Java 8 之前就已经有了大量的函数式接口，我们最熟悉的就是 `java.lang.Runnable`接口了。Java 8 之前已有的函数式接口：

*  `java.lang.Runnable`
 *  `java.util.concurrent.Callable`
 *  `java.security.PrivilegedAction`
 *  `java.util.Comparator`
 *  `java.io.FileFilter`
 *  `java.nio.file.PathMatcher`
 *  `java.lang.reflect.InvocationHandler`
 *  `java.beans.PropertyChangeListener`
 *  `java.awt.event.ActionListener`
 *  `javax.swing.event.ChangeListener`

而在 Java 8 中，新增的函数式接口都在 `java.util.function` 包中，里面有很多函数式接口，用来支持 Java 的函数式编程，从而丰富了 Lambda 表达式的使用场景。我们使用最多的也是最核心的函数式接口有四个：

*  `java.util.function.Consumer`：消费型接口
 *  `java.util.function.Function`：函数型接口
 *  `java.util.function.Supplier`：供给型接口
 *  `java.util.function.Predicate`：断定型接口

下面我们就来看这四个函数式接口的使用方法

#### Consumer 接口 ####

Consumer 代表这一个接受一个输入参数并且不返回任何结果的操作。它包含一个抽象方法 `accept(T t)`，该方法接受一个参数 `t`，并对该参数执行某种操作：

@FunctionalInterface
    public interface Consumer<T> {
        void accept(T t);
    }

由于 Consumer 接口中包含的抽象方法不返回结果，所以它通常用于对对象进行一些操作，如修改、输出、打印等。它的使用方法也比较简单，分为两步。

1.  **创建一个 Consumer 对象**：使用 Lambda 表达式来创建一个对象，定义在 `accept(T t)` 中要执行的操作。

Consumer<String> consumer = str -> System.out.println(str);

1.  **使用 Consumer 对象**

consumer.accept("死磕 Java 就是牛...");
    
    // 输出结果...
    
    死磕 Java 就是牛...

在 Consumer 接口中还有一个默认方法 `andThen()`，该方法接受一个 Consumer 实例对象 after，它允许我们将两个 Consumer 对象组合在一起，形成一个新的 Consumer 对象，该新对象按照顺序执行这两个 Consumer 对象的操作。先执行调用`andThen()`接口的`accept()`，然后再执行`andThen()`参数after中的`accept()`。

Consumer<String> consumer1 = str -> System.out.println("consumer1：" + str);
    Consumer<String> consumer2 = str -> System.out.println("consumer2：" + str);
    
    consumer1.andThen(consumer2).accept("死磕 Java 就是牛..");
    
    // 输出结果...
    
    consumer1：死磕 Java 就是牛..
    consumer2：死磕 Java 就是牛..

#### Function 接口 ####

Function 代表一个接受一个输入参数并且产生一个输出结果的函数。它包含一个抽象方法 `R apply(T t)`，该方法接受一个参数 `t`（类型为 `T`），并返回一个结果（类型为 `R`），我们可以理解为根据一个数据类型 T ，经过一系列的操作后得到类型 R。Function 接口是非常通用的，应该是他们四个当中使用最为广泛的。

> **用途一：函数转换**

Function 可以用于将一个类型的值转换为另一个类型的值。它可以用于各种转换操作，如类型转换、数据映射等。

Function<String,Integer> function = str -> Integer.parseInt(str);
    int result = function.apply("456");
    // 输出结果...
    456

> **用途二：数据处理**

Function 可用于对输入数据进行处理并生成输出结果。它可以用于执行各种操作，如过滤、计算、提取、格式化等。

Function<List<String>, String> function = list -> {
        StringBuilder result = new StringBuilder();
            for (String str : list) {
                if (str.startsWith("李")) {
                    result.append(str).append(",");
                }
            }
    
            return result.toString();
        };
    List<String> list = Arrays.asList("张三","李四","李武","李柳");
    System.out.println(function.apply(list));
    // 输出结果...
    李四,李武,李柳,

> `andThen()`**：方法链式调用**

`andThen()` 接受一个 Function 作为参数，并返回一个新的 Function，该新函数首先应用当前函数，然后将结果传递给参数函数。这种方法链的方式可以用于将多个函数组合在一起，以执行一系列操作。

Function<String,Integer> function1 = t -> Integer.parseInt(t);
    Function<Integer,Integer> function2 = t -> t * 10;
    System.out.println(function1.andThen(function2).apply("20"));

先将 String 转换为 Integer，然后再 `* 10`，利用 `andThen()` 我们可以进行一系列复杂的操作。

> `compose()`**：顺序执行**

`compose()` 与 `andThen()`相反，它首先应用参数函数，然后再应用当前函数，这种可能更加好理解些，常用于一些顺序执行。

Function<String,Integer> function1 = t -> {
      System.out.println("function1");
      return Integer.parseInt(t);
    };
    Function<Integer,Integer> function2 = t -> {
      System.out.println("function2");
      return t * 10;
    };
    Function<Integer,String> function3 = t -> {
      System.out.println("function3");
      return t.toString();
    };
    System.out.println(function3.compose(function2.compose(function1)).apply("20"));
            
    // 输出结果...
    function1
    function2
    function3
    200

从输出结果中可以更加直观地看清楚他们的执行顺序。

> `identity()`：**恒等函数**

`identity()` 返回一个恒等函数，它仅返回其输入值，对输入值不进行任何操作。源码如下：

static <T> Function<T, T> identity() {
            return t -> t;
        }

一看感觉 `identity()` 没啥用处，其实它在某些场景大有用处，例如

*  **作为默认函数**

`identity()` 可以作为函数组合链中的起点或默认函数。当我们想构建一个函数组合链时，可以使用 `identity` 作为初始函数，然后使用 `andThen()` 或 `compose()` 方法添加其他函数。这种方式允许您以一种优雅的方式处理链的起点。

Function<String,String> function1 = Function.identity();
    Function<String,String> function2 = str -> str.toUpperCase();
    Function<String,String> function3 = str -> str + " WORLD!!!";
    
    System.out.println(function3.compose(function2.compose(function1)).apply("hello"));
    复制代码

*  **保持一致性**

在某些情况下，我们可能需要一个函数，但不需要对输入进行任何操作。使用 `identity()` 可以确保函数的签名（输入和输出类型）与其他函数一致。

#### Supplier 接口 ####

Supplier 是一个代表生产（或供应）某种结果的接口，它不接受任何参数，但能够提供一个结果。它定义了一个 `get()` 的抽象方法，用于获取结果。

接口定义简单，使用也简单：

Supplier<LocalDate> supplier = () -> LocalDate.now();
    LocalDate localDate = supplier.get();

Supplier 接口通常用于惰性求值，只有在需要结果的时候才会执行 `get()` 。这对于延迟计算和性能优化非常有用。

#### Predicate 接口 ####

Predicate 表示一个谓词，它接受一个输入参数并返回一个布尔值，用于表示某个条件是否满足。抽象方法为 `test()`，使用如下：

Predicate<String> predicate = str -> str.length() > 10;
    boolean result = predicate.test("www.skjava.com");

判断某个字符长度是否大于 10。

> `and()`：表示两个 Predicate 的 与操作

Predicate<Integer> predicate1 = x -> x > 10;
    Predicate<Integer> predicate2 = x -> x % 2 == 0;
    boolean result = predicate1.and(predicate2).test(13);

> `or()`：表示两个 Predicate 的或操作

Predicate<Integer> predicate1 = x -> x > 10;
    Predicate<Integer> predicate2 = x -> x % 2 == 0;
    boolean result = predicate1.or(predicate2).test(13);

> `negate()`：表示 Predicate 的逻辑非操作

Predicate<Integer> predicate1 = x -> x > 10;
    boolean result = predicate1.negate().test(14);

#### 其他函数式接口 ####

除了上面四个常用的函数式接口外，`java.util.function` 包下面还定义了很多函数式接口，下面做一个简单的介绍：

<table> 
 <thead> 
  <tr> 
   <th>接口</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>BiConsumer&lt;T,U&gt;</td> 
   <td>表示接受两个不同类型的参数，但不返回任何结果的操作</td> 
  </tr> 
  <tr> 
   <td>BiFunction&lt;T,U,R&gt;</td> 
   <td>表示接受两个不同类型的参数，并返回一个其它类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>BinaryOperator</td> 
   <td>表示接受两个相同类型的参数，并返回一个同一类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>BiPredicate&lt;T,U&gt;</td> 
   <td>表示接受两个不同诶行的参数，且返回布尔类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>BooleanSupplier</td> 
   <td>不接受任何参数，且返回一个布尔类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>DoubleBinaryOperator</td> 
   <td>表示接受两个double类型的参数，并返回double类型结果的操作</td> 
  </tr> 
  <tr> 
   <td>DoubleConsumer</td> 
   <td>表示接受一个double类型的参数，但不返回任何结果的操作</td> 
  </tr> 
  <tr> 
   <td>DoubleFunction</td> 
   <td>表示接受一个double类型的参数，且返回一个R类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>DoublePredicate</td> 
   <td>表示一个接受两个double类型的参数，且返回一个布尔类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>DoubleSupplier</td> 
   <td>表示一个不接受任何参数，但返回布尔类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>DoubleToIntFunction</td> 
   <td>表示接受两个double类型的参数，但返回一个int类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>DoubleToLongFunction</td> 
   <td>表示接受两个double类型的参数，但返回一个long类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>DoubleUnaryOperator</td> 
   <td>表示接受一个double类型的参数，且返回一个double类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>IntBinaryOperator</td> 
   <td>表示一个接受两个int类型的参数，且返回一个int类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>IntConsumer</td> 
   <td>表示接受一个int类型的参数，但不返回任何结果的操作</td> 
  </tr> 
  <tr> 
   <td>IntFunction</td> 
   <td>表示接受一个int类型的参数，但返回一个R类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>IntPredicate</td> 
   <td>表示接受一个int类型的参数，但返回布尔类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>IntSupplier</td> 
   <td>表示不接受任何参数，但返回一个int类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>IntToDoubleFunction</td> 
   <td>表示接受一个int类型的参数，但返回一个double类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>IntToLongFunction</td> 
   <td>表示接受一个int类型的参数，但返回一个long类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>IntUnaryOperator</td> 
   <td>表示接受一个int类型的参数，且返回一个int类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>LongBinaryOperator</td> 
   <td>表示接受两个long类型的参数，且返回一个long类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>LongConsumer</td> 
   <td>表示不接受任何参数，但返回一个long类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>LongFunction</td> 
   <td>表示接受一个loing类型的参数，但返回一个R类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>LongPredicate</td> 
   <td>表示接受一个long类型的参数，但返回布尔类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>LongSupplier</td> 
   <td>表示不接受任何参数，但返回一个long类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>LongToDoubleFunction</td> 
   <td>表示接受一个long类型的参数，但返回一个double类型的结果的函数</td> 
  </tr> 
  <tr> 
   <td>LongToIntFunction</td> 
   <td>表示接受一个long类型的参数，但返回int类型的结果的函数</td> 
  </tr> 
  <tr> 
   <td>LongUnaryOperator</td> 
   <td>表示接受一个long类型的参数，并返回一个long类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>ObjDoubleConsumer</td> 
   <td>表示接受两个参数，一个为T类型的对象，另一个double类型，但不返回任何结果的操作</td> 
  </tr> 
  <tr> 
   <td>ObjIntConsumer</td> 
   <td>表示接受两个参数，一个为T类型的对象，另一个int类型，但不返回任何结果的操作</td> 
  </tr> 
  <tr> 
   <td>ObjLongConsumer</td> 
   <td>表示接受两个参数，一个为T类型的对象，另一个double类型，但不返回任何结果的操作</td> 
  </tr> 
  <tr> 
   <td>ToDoubleBiFunction&lt;T,U&gt;</td> 
   <td>表示接受两个不同类型的参数，但返回一个double类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>ToDoubleFunction</td> 
   <td>表示一个接受指定类型T的参数，并返回一个double类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>ToIntBiFunction&lt;T,U&gt;</td> 
   <td>表示接受两个不同类型的参数，但返回一个int类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>ToIntFunction</td> 
   <td>表示一个接受指定类型T的参数，并返回一个int类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>ToLongBiFunction&lt;T,U&gt;</td> 
   <td>表示接受两个不同类型的参数，但返回一个long类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>ToLongFunction</td> 
   <td>表示一个接受指定类型的参数，并返回一个long类型的结果的操作</td> 
  </tr> 
  <tr> 
   <td>UnaryOperator</td> 
   <td>表示接受一个参数，并返回一个与参数类型相同的结果的操作</td> 
  </tr> 
 </tbody> 
</table>

函数式接口使用非常灵活，上面的举例都是很简单的 demo，它需要我们在日常开发过程中多多使用才能灵活地运用它。

--------------------

## Java 8 新特性—方法引用和构造器引用 ##

在前面我们了解了 [Lambda 表达式][Lambda]，它能够简化我们的程序，但是它还不是最简单的，Java 8 引入了方法引用可以对 Lambda 表达式再进一步简化。

![img][img 5]

### 什么是方法引用 ###

我们先看一个例子。首先定义一个 Student 类：

public class Student {
        private String name;
    
        private Integer age;
    
        public static int compareByAge(Student a,Student b) {
            return a.getAge().compareTo(b.getAge());
        }
    }

Student 中含有一个静态方法 `compareByAge()`，它是用来比较年龄的。

现在需要实现一个需求，有一批学生我们希望能够根据 age 进行排序。

在没有学习 Lambda 表达式时，我们这样写：

public class MethodReferenceTest {
        public static void main(String[] args) {
            List<Student> studentList = Arrays.asList(
                    new Student("小明",16),
                    new Student("小红",14),
                    new Student("小兰",15),
                    new Student("小李",18),
                    new Student("小张",14),
                    new Student("小林",15)
            );
    
            Collections.sort(studentList, new Comparator<Student>() {
                @Override
                public int compare(Student o1, Student o2) {
                    return o1.getAge().compareTo(o2.getAge());
                }
            });
            System.out.println(studentList);
        }
    }

学习了 Lambda 表达式后，我们知道 Comparator 接口是一个函数式接口，因此我们可以使用Lambda表达式，而不需要使用这种匿名内部类的方式：

public class MethodReferenceTest {
        public static void main(String[] args) {
            // 省略代码...
    
            Collections.sort(studentList, (o1,o2) -> Student.compareByAge(o1,o2));
            System.out.println(studentList);
        }
    }

注意，这里我们是使用 Student 类中的静态方法：`compareByAge()`。到这里后其实还有进一步的优化空间：

public class MethodReferenceTest {
        public static void main(String[] args) {
            // 省略代码...
    
            Collections.sort(studentList, Student::compareByAge);
            System.out.println(studentList);
        }
    }

这段代码将 Lambda 表达式 `(o1,o2) -> Student.compareByAge(o1,o2)` 转变为了 `Student::compareByAge` 是不是很懵逼？

`Student::compareByAge` 写法就是我们这篇文章要讲的方法引用。那什么是方法引用呢？

> 方法引用是 Java 8 引入的特性，它提供了一种更加简洁的可用作 Lambda 表达式的表达方式。 定义：**方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。**

我们可以简单认为，方法引用是一种更加简洁易懂的 Lambda表达式。当 Lambda 表达式的主体中只有一个执行方法的调用时，我们可以不使用 Lambda 表达式，而是选择更加简洁的方法引用，这样可读性更高一些。

### 三种方法引用类型 ###

方法引用的标准格式是：`类名::方法名`。它有如下三种类型：

<table> 
 <thead> 
  <tr> 
   <th><strong>类型</strong></th> 
   <th><strong>格式</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>引用静态方法</td> 
   <td><code>类名::静态方法名</code></td> 
  </tr> 
  <tr> 
   <td>引用对象的实例方法</td> 
   <td><code>实例对象::方法名</code></td> 
  </tr> 
  <tr> 
   <td>引用类型的任意对象的实例方法</td> 
   <td><code>类名::实例方法名</code></td> 
  </tr> 
 </tbody> 
</table>

下面我们来看这三种类型的使用方法。

#### 引用静态方法 ####

引用静态方法的格式是：`类名::静态方法名`。这个是其实和我们使用静态方法一样，只不过是将 `“.”` 替换成了 `“::”`。其实我们上面那个例子就是引用静态方法的例子，这里大明哥再举一个示例，`java.lang.Math` 中有很多静态方法，比如：

// Lambda 表达式
    Function<Integer,Integer> function1 = t -> Math.abs(t);
    int result1 = function1.apply(-123);
            
    // 方法引用
    Function<Integer,Integer> function2 = Math::abs;
    int result2 = function2.apply(-123);

#### 引用对象的实例方法 ####

引用对象的实力方法格式是：`实例对象名::实例方法名`，这种方式引用的是一个实例方法，所以需要提供一个对象实例来引用，如下：

Student student = new Student("小明",15);
    
    // Lambda 表达式
    Supplier<String> supplier1 = () -> student.getName();
    String name1 = supplier1.get();
     
    // 方法引用  
    Supplier<String> supplier2 = student::getName;
    String name2 = supplier2.get();

这种方式在我们使用 Stream 来操作集合时用得非常多。

#### 引用类型的任意对象的实例方法 ####

引用类型的任意对象的实例方法的格式是：`类名::实例方法名`，这个有点儿不是很好理解。这种引用方式引用的是一个特定对象的实例方法，通常在函数式接口中作为第一个参数传递给方法引用，怎么理解呢？我们看下面两个例子：

比如 Comparator 中的 `int compare(T o1, T o2)`，我们需要比较两个字符串的大小，使用方式如下：

Comparator<String> comparator = (o1,o2) -> o1.compareTo(o2);
    System.out.println(comparator.compare("sike","sk"));

改成 `类名::实例方法名` 怎么改呢？

Comparator<String> comparator = String::compareTo;
    System.out.println(comparator.compare("sike","sk"));

是不是比较懵逼？再看一个：

// Lambda 表达式
    List<String> list = Arrays.asList("xiaoming","xiaohong","xiaoli","xiaodu");
    list.forEach(name -> name.toUpperCase());
    // 方法引用
    List<String> list = Arrays.asList("xiaoming","xiaohong","xiaoli","xiaodu");
    list.forEach(String::toUpperCase);

是不是比较懵？其实大明哥看到这个也比较懵，确实是不好理解，但是没关系，最后面大明哥教你们一个终极神器，让你使用方法引用不再困难。

### 方法引用的前提条件 ###

方法引用确实可以极大地降低我们的代码量也更加清晰了，但是并不是所有的 Lambda 表达式都可以转换为方法引用。它有如下几个前提条件。

> **1、Lambda 表达式中只有一个调用方法的代码**

注意这个**一个调用方法**的含义，它包含两重意思。

*  只有一行代码

List<String> list = Arrays.asList("xiaoming","xiaohong","xiaoli","xiaodu");
    list.forEach(name -> {
        System.out.println("www.skjava.com");
        name.toUpperCase();
    });

这个 Lambda 中有两行代码，这是无法转换为方法引用的。

*  只有一个调用方法

List<String> list = Arrays.asList("xiaoming","xiaohong","xiaoli","xiaodu");
    list.forEach(name -> System.out.println(name.toUpperCase()));

这种写法也是转换不了的，虽然只有一行代码，但是它调用了两个方法。

> **2、方法引用的目标方法必须与Lambda 表达式的函数接口的抽象方法参数类型和返回类型相匹配**

这就意味着目标方法的参数数量、类型以及返回类型必须与函数接口的要求一致。但是它只能规范**引用静态方法**和**引用对象的实例方法**，而**引用类型的任意对象的实例方法**这种类型其实是不适用。

> **3、如果方法引用是通过对象引用来实现的，那么 Lambda 表达式中的参数列表的第一个参数必须是方法**

[img]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/0370cd70bc3143a8b69232c7bcb1b076.png
[img 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/fb87601aa2ab400a89c461c52c0ef782.png
[img 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/8b916b5253e74a9386200cee7d5e45ee.png
[img 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/39ad8a4aabf04422854af6f8b6a2305a.jpeg
[img 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/27739d36e9b147988e532bc6be77b619.jpeg
[Lambda]: https://www.skjava.com/series/article/1747461365
[img 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/97cb1e126546432aa057a683d71e51d9.png