Java9新特性

注： IntelliJ IDEA 2017.3 支持模块化特性，这里选择此开发环境。 

---

一、Java 9 概述 

1. jdk 9 的发布 

经过4次跳票，历经曲折的java 9 终于终于在2017年9月21日发布。

2. Java 9 中哪些不得不说的新特性？ 

java 9 提供了超过 150 项新功能特性，包括备受期待的模块化系统、 可交互的 REPL 工具：jshell，JDK 编译工具，Java 公共 API 和私有代码，以及安全增强、扩展提升、性能管理改善等。可以说 Java 9 是 一个庞大的系统工程，完全做了一个整体改变。

具体来讲：

• 模块化系统 
• jShell 命令 
• 多版本兼容 jar 包 
• 接口的私有方法 
• 钻石操作符的使用升级 
• 语法改进：try 语句 
• 下划线使用限制 
• String 存储结构变更 
• 便利的集合特性：of() 
• 增强的 Stream API 
• 多分辨率图像 API 
• 全新的 HTTP 客户端 API 
• Deprecated 的相关 API 
• 智能 Java 编译工具 
• 统一的 JVM 日志系统 
• javadoc 的 HTML 5 支持 
• Javascript 引擎升级：Nashorn 
• java 的动态编译器 

 4. java 语言后续版本的更迭 

•  从Java 9 这个版本开始，Java 的计划发布周期是 6 个月，下一个 Java 的主版本将于 2018 年 3 月发布，命名为 Java 18.3，紧 接着再过六个月将发布 Java 18.9。
• 这意味着java的更新从传统的以特性驱动的发布周期，转变为以时间驱动的（6 个月为周期）发布模式，并逐步的将 Oracle JDK 原商业特性进行开源。
• 针对企业客户的需求，Oracle 将以三年为周期发布长期支持版本 （long term support）。 

 5. 如何看待 java 9 的更新 

Java 更快的发布周期意味着开发者将不需要像以前一样为主要发布版本望眼欲穿。这也意味着开发者将可能跳过 Java 9 和它的不成熟的模块化功能，只需要再等待 6 个月就可以迎来新版本，这将可能解决开发者的纠结。 

 

oracle 理念  与 小步快跑，快速迭代 

 

---

二、 java 9 的安装和官网说明 

 

1.jdk 9 的下载

https://www.oracle.com/technetwork/java/javase/downloads/jdk9-downloads-3848520.html

下载安装完毕，需要配置环境变量：

① 新建 JAVA_HOME 的环境变量，变量值为 jdk 路径。如下： 
 

② 将 JAVA_HOME 配置到 path 环境变量下： 

之后在命令行校验是否配置成功。成功，则显示如下： 

 2. java 9 帮助文档的下载 

http://www.oracle.com/technetwork/java/javase/documentation/jdk9-d oc-downloads-3850606.html 

 3. 在线 Oracle JDK 9 Documentation 

https://docs.oracle.com/javase/9/ 

 

---

三、Java 9 的新特性 

官方提供的新特性列表：

https://docs.oracle.com/javase/9/whatsnew/toc.htm#JSNEW-GUID-C23 AFD78-C777-460B-8ACE-58BE5EA681F6 
 
或参考 Open JDK:  https://openjdk.java.net/projects/jdk9/

http://openjdk.java.net/jeps/0

• JEP(JDK Enhancement Proposals)：jdk 改进提案，每当需要有新的 设想时候，JEP 可以在 JCP(java community Process)之前或者同时提 出非正式的规范(specification)，被正式认可的 JEP 正式写进 JDK 的 发展路线图并分配版本号。
• JSR(Java Specification Requests)：java 规范提案，新特性的规范出 现在这一阶段，是指向 JCP(Java Community Process)提出新增一个 标准化技术规范的正式请求。请求可以来自于小组/项目、JEP、JCP 成员或者 java 社区(community)成员的提案，每个 java 版本都由相 应的 JSR 支持。

            小组：对特定技术内容，比如安全、网络、HotSpot 等有共同 兴趣的组织和个人

            项目：编写代码、文档以及其他工作，至少由一个小组赞助和 支持，比如最近的 Lambda 计划，JigSaw 计划等

1. JDK 和 JRE 的改变 

1.1 JDK 与 JRE 的关系 

JDK : Java Development Kit (Java 开发工具包) 

JRE : Java Runtime Environment (Java 运行环境) 

 说明：

JDK = JRE + 开发工具集（例如 Javac 编译工具等）

JRE = JVM + Java SE 标准类库 

1.2 JDK 8 的目录结构 

说明：  

bin 目录	包含命令行开发和调试工具，如 javac ，jar 和 javadoc。
include目录	包含在编译本地代码时使用的C/C++头文件
lib 目录	包含JDK工具的几个JAR和其他类型的文件。它有一个tools.jar 文件，其中包含 Javac 编译器的 Java 类
jre/bin 日录	包含基本命令，如 java 命令。在 Windows平台上，它包含系统的运行时动态链接库（DLL）。
jre/lib 目录	包含用户可编辑的配置文件，如 .properties和 .policy文件。包含几个JAR ,rt.jar文件包含运行时的  Java 类和资源文件。

 

 

 

 

 

 

 

 

 1.3 JDK 9 的目录结构 

说明： 

 

没有名为 jre 的子目录
bin 目录	包含所有命令。 在 Windows 平台上，它继续包含系 统的运行时动态链接库。
conf 目录	包含用户可编辑的配置文件，例如以前位于 jre\lib 目 录中的.properties 和.policy 文件
include 目录	包含要在以前编译本地代码时使用的 C/C++头文件。 它只存在于 JDK 中
jmods 目录	包含 JMOD 格式的平台模块。 创建自定义运行时映像 时需要它。 它只存在于 JDK 中
legal 目录	包含法律声明
lib 目录	包含非 Windows 平台上的动态链接本地库。 其子目 录和文件不应由开发人员直接编辑或使用

 

 

 

 

 

 

 

 

2. 模块化系统: Jigsaw --->  Modularity 

2.1 官方 Feature 

200: The Modular JDK 
201: Modular Source Code 
220: Modular Run-Time Images 
260: Encapsulate Most Internal APIs 
261: Module System 
282: jlink: The Java Linker 

2.2 产生背景及意义 

• 谈到 Java 9 大家往往第一个想到的就是 Jigsaw 项目。众所周知， Java 已经发展超过 20 年（95 年最初发布），Java 和相关生态 在不断丰富的同时也越来越暴露出一些问题：

            >> Java 运行环境的膨胀和臃肿。每次JVM启动的时候，至少会有 30～60MB的内存加载，主要原因是JVM需要加载rt.jar，不管 其中的类是否被 classloader 加载，第一步整个jar都会被JVM加载到内存当中去（而模块化可以根据模块的需要加载程序运行需要的class）

            >> 当代码库越来越大，创建复杂，盘根错节的“意大利面条式代 码”的几率呈指数级的增长。不同版本的类库交叉依赖导致让 人头疼的问题，这些都阻碍了 Java 开发和运行效率的提升。
            >> 很难真正地对代码进行封装, 而系统并没有对不同部分（也就 是 JAR 文件）之间的依赖关系有个明确的概念。每一个公共类都可以被类路径之下任何其它的公共类所访问到，这样就会导致无意中使用了并不想被公开访问的 API。

            >> 类路径本身也存在问题: 你怎么知晓所有需要的 JAR 都已经有了, 或者是不是会有重复的项呢? 

• 同时，由于兼容性等各方面的掣肘，对 Java 进行大刀阔斧的革新越来越困难，Jigsaw 从 Java 7 阶段就开始筹备，Java 8 阶段进行了大量工作，终于在 Java 9 里落地，一种千呼万唤始出来的意味。
• Jigsaw项目（后期更名为Modularity）的工作量和难度大大超出了 初始规划。JSR 376 Java 平台模块化系统（JPMS, Java Platform Module System）作为 Jigsaw 项目的核心, 其主体部分被分解成 6 个 JEP(JDK Enhancement Proposals)。
• 作为java 9 平台最大的一个特性，随着 Java 平台模块化系统的落地，开发人员无需再为不断膨胀的 Java 平台苦恼，例如，您可以使用 jlink 工具，根据需要定制运行时环境。这对于拥有大量镜像的容器应用场景或复杂依赖关系的大型应用等，都具有非常 重要的意义。 
• 本质上讲，模块(module)的概念，其实就是package外再裹一层， 也就是说，用模块来管理各个package，通过声明某个package暴露， 不声明默认就是隐藏。因此，模块化使得代码组织上更安全，因 为它可以指定哪些部分可以暴露，哪些部分隐藏。 

2.3 设计理念  

模块独立、化繁为简 

模块化（以 Java 平台模块系统的形式）将 JDK 分成一组模块，可 以在编译时，运行时或者构建时进行组合。

2.4 实现目标 

• 主要目的在于减少内存的开销 
• 只须必要模块，而非全部jdk模块，可简化各种类库和大型应用的 开发和维护 
• 改进 Java SE 平台，使其可以适应不同大小的计算设备 
• 改进其安全性，可维护性，提高性能

2.5 使用举例 

模块将由通常的类和新的模块声明文件（module-info.java）组成。 该文件是位于 java 代码结构的顶层，该模块描述符明确地定义了我们的模块需要什么依赖关系，以及哪些模块被外部使用。在 exports 子 句中未提及的所有包默认情况下将封装在模块中，不能在外部使用。
 

java 9demo 模块中的 ModuleTest 类使用如下： 

package com.atguigu.java;

import com.atguigu.bean.Person;
import org.junit.Test;
import java.util.logging.Logger;
public class ModuleTest {
    private static final Logger LOGGER = Logger.getLogger("java9test");
    public static void main(String[] args){
        Person p = new Person("马云",40);
        System.out.println(p);

        LOGGER.info("测试");

//        User u = new User();  无法访问
    }

    @Test
    public void test1(){
        System.out.println("hello");
    }
}

对应在 java 9demo 模块的 src 下创建 module-info.java 文件： 

注：没找到 module-info.java 选项，可以在桌面创建一个 module-info.java 文件在复制到 idea 中。在idea中创建 java 文件是不可以取这个名字的。（命名不符合）

module java9demo{
    requires java9test;
    requires java.logging;
    requires junit;
}

requires：指明对其它模块的依赖。 

在 java9test 模块的指定包下提供类 Person： 

package com.atguigu.bean;

public class Person {
    private String name;
    private int age;
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}

要想在 java9demo 模块中调用 java9test 模块下包中的结构，需要在java9test 的 module-info.java 中声明： 

module java9test{
    //导出我们想要导出的包
    exports com.atguigu.bean;
}

exports：控制着哪些包可以被其它模块访问到。所有不被导出的包 默认都被封装在模块里面。 

 

在 ModuleTest  就访问不了 User

package com.atguigu.entity;

public class User {
    private String name;
    private int age;
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public User() {
    }
}

 

2.6 补充说明 

关于更多 Java 9 模块编程的内容请参考一本书：《Java 9 Modularity》 里面讲的比较详细，介绍了当前 Java 对 jar 之间以来的管理是多么的 混乱，引入 modularity 之后的改变会是很明显的差别。 

 

 

---

3. Java 的 REPL 工具： jShell 命令 

3.1 官方 Feature 

222: jshell: The Java Shell (Read-Eval-Print Loop) 

3.2 产生背景 

像 Python 和 Scala 之类的语言早就有交互式编程环境 REPL (read - evaluate - print - loop)了，以交互式的方式对语句和表达式进行求值。 开发者只需要输入一些代码，就可以在编译前获得对程序的反馈。而之前的 Java 版本要想执行代码，必须创建文件、声明类、提供测试 方法方可实现。 

3.3 设计理念 

即写即得、快速运行 

3.4 实现目标 

• Java 9 中终于拥有了 REPL 工具：jShell。利用 jShell 在没有创建类 的情况下直接声明变量，计算表达式，执行语句。即开发时可以 在命令行里直接运行 java 的代码，而无需创建 Java 文件，无需跟 人解释”public static void main(String[] args)”这句废话。
• jShell 也可以从文件中加载语句或者将语句保存到文件中。
• jShell 也可以是 tab 键进行自动补全和自动添加分号。 

 3.5 使用举例 

调出 jShell 
 

获取帮助 

基本使用 

jshell> System.out.println("你好！world");
你好！world

jshell> int i = 10;
i ==> 10

jshell> int j = 20;
j ==> 20

jshell> int k = i + j;
k ==> 30

jshell> System.out.print(k);
30

创建函数： 

jshell> public int add(int m, int n){
   ...> return m+n;
   ...> }
|  已创建 方法 add(int,int)

jshell> int k = add(1,2);
k ==> 3

jshell> System.out.print(k);
3

Tips：在 JShell 环境下，语句末尾的“;” 是可选的。但推荐还是最好加上。提 高代码可读性。 

导入指定的包 

jshell> import java.util.*;

 默认已经导入如下的所有包：（包含 java.lang 包） 

jshell> /imports
|    import java.io.*
|    import java.math.*
|    import java.net.*
|    import java.nio.file.*
|    import java.util.concurrent.*
|    import java.util.function.*
|    import java.util.prefs.*
|    import java.util.regex.*
|    import java.util.stream.*
|    import java.util.*

jshell>

只需按下 Tab 键，就能自动补全代码 

jshell> Sy
SyncFailedException   SynchronousQueue      System

jshell> System.out
out

jshell> System.out.
append(        checkError()   close()        equals(        flush()
format(        getClass()     hashCode()     notify()       notifyAll()
print(         printf(        println(       toString()     wait(
write(

jshell> System.out.

列出当前 session 里所有有效的代码片段 

查看当前 session 下所有创建过的变量 

查看当前 session 下所有创建过的方法 

Tips：我们还可以重新定义相同方法名和参数列表的方法，即为对现有方法的修 改（或覆盖）。 

使用外部代码编辑器来编写 Java 代码 

从外部文件加载源代码 

F盘创建一个HelloWorld.java 文件： 

//注意这个和以前写的java 程序还是有点差别的
	public void printHello(){
		System.out.println("HelloWorld");
}
printHello();

使用/open 命令调用： 

jshell> /open F:\HelloWorld.java
HelloWorld

没有受检异常（编译时异常） 

jshell> URL url = new URL("https://music.163.com");
url ==> https://music.163.com

说明：本来应该强迫我们捕获一个 IOException，但却没有出现。因为 jShell 在后台为我们隐藏了。  

//java 程序里面 要么抛出 要么 try
@Test
public void test(){
    try {
        URL url = new URL("https://music.163.com");
    } catch (MalformedURLException e) {
        e.printStackTrace();
    }
}

退出 jShell 

jshell> /exit
|  再见

 jshell> /
/!          /?          /drop       /edit       /env        /exit
/help       /history    /imports    /list       /methods    /open
/reload     /reset      /save       /set        /types      /vars

 

---

 4. 多版本兼容 jar 包 

4.1 官方 Feature 

238: Multi-Release JAR Files 

4.2 使用说明 

当一个新版本的 Java 出现的时候，你的库用户要花费数年时间才会切换到这个新的版本。这就意味着库得去向后兼容你想要支持的最老的 Java 版本（许多情况下就是 Java 6 或者 Java7）。这实际上意味着 未来的很长一段时间，你都不能在库中运用 Java 9 所提供的新特性。 幸运的是，多版本兼容 jar 功能能让你创建仅在特定版本的 Java 环境 中运行库程序选择使用的 class 版本。 

举例 1： 

jar root
    - A.class
    - B.class
    - C.class
    - D.class
    - META-INF
        - versions
            - 9            
                - A.class            
                - B.class 

 说明：

在上述场景中， root.jar 可以在 Java 9 中使用, 不过 A 或 B 类使用的不是顶层的 root.A 或 root.B 这两个 class, 而是处在 “META-INF/versions/9”下面的这两个。这是特别为 Java 9 准备的 class 版本，可以运用 Java 9 所提供的特性和库。同时，在早期的 Java 诸版本中使用这个 JAR 也是能运行的，因为较老版本的 Java 只会看 到顶层的 A 类或 B 类。 

举例 2：  

 jar root
    - A.class
    - B.class
    - C.class
    - D.class
    - META-INF
        - versions
            - 9            
                - A.class            
                - B.class 
            -10
                - A.class            
                - B.class 

官方说明：

By this scheme, it is possible for versions of a class designed for a later Java platform release to override the version of that same class designed for an earlier Java platform release. 

通过这样的一个规定，这是可能的，我们最近的一个 Java 稳定版的平台，它会取覆盖我们之前 Java平台中（jdk）中同名的类，说白了就是一个完全覆盖的关系。

 4.3 使用举例 

文件的目录结构：

multijar
    └─src
        └─main
            ├─java
            │  └─com
            │      └─atguigu
            │              Application.java
            │              Generator.java
            │
            └─java-9
                └─com
                    └─atguigu
                            Generator.java

 步骤一：提供必要的类 

在指定目录(...\multijar\src\main\java\com\atguigu)下创建 Generator.java 

package com.atguigu;

import java.util.Set;
import java.util.HashSet;
/**
 * Created by songhongkang on 2017/12/28 0028.
 */
public class Generator {

    public Set createStrings() {
        Set strings = new HashSet();
        strings.add("Java");
        strings.add("8");
        return strings;
    }
}

  创建 Application.java

package com.atguigu;

import java.io.IOException;
import java.util.List;
import java.util.ArrayList;
import java.util.Set;
/**
 * Created by songhongkang on 2017/12/28 0028.
 */
public class Application {

   public static void testMultiJar(){
      Generator gen = new Generator();
      System.out.println("Generated strings: " + gen.createStrings());
   }

}

在如下目录(....\multijar\src\main\java-9\com\atguigu) 下提供同名的类： Generator.java 

package com.atguigu;

import java.util.Set;
/**
 * Created by songhongkang on 2017/12/28 0028.
 */
public class Generator {
        
    public Set createStrings() {
        return Set.of("Java", "9");//java9 新增加的
    }

}

步骤二：打包 

指令如下： 

javac -d build --release 8 src/main/java/com/atguigu/*.java

javac -d build9 --release 9 src/main/java-9/com/atguigu/*.java

jar --create --main-class=Application --file multijar.jar -C build .

 

 

 

 

 进入 multijar 目录里面

 步骤三：在 java 9 及之前版本的环境下进行测试即可 

1. 工程下创建一个 Directory(目录) lib 用于保存jar包
2. 把打包好的 jar 包复制到 lib 目录下即可
3. 右键导入的包，Add as Libray (导入)

java8环境：

public class TestDemo {
    public static void main(String[] args){
        Application.testMultiJar();
    }
}

 

只需要打开项目结构（Ctrl+Alt+Shift+S），修改模块即可切换到java9

java9:

 

---

 5. 语法改进：接口的私有方法 

 5.1 官方 Feature 

213: Milling Project Coin 

 Support for private methods in interfaces was briefly in consideration for inclusion in Java SE 8 as part of the effort to add support for Lambda Expressions, but was withdrawn to enable better focus on higher priority tasks for Java SE 8. It is now proposed that support for private interface methods be undertaken thereby enabling non abstract methods of an interface to share code between them. 

在接口中对私有方法的支持被简单地考虑为包含在Java SE 8中，作为增加对lambda表达式的支持的一部分，但是被撤回以更好地关注Java SE 8的更高优先级的任务。现在建议对私有接口方法进行支持，从而使接口的非抽象方法能够在它们之间共享代码。

5.2 使用说明 

Java 8 中规定接口中的方法除了抽象方法之外，还可以定义静态 方法和默认的方法。一定程度上，扩展了接口的功能，此时的接口更 像是一个抽象类。 

在 Java 9 中，接口更加的灵活和强大，连方法的访问权限修饰符 都可以声明为 private 的了，此时方法将不会成为你对外暴露的 API 的一部分。 

5.3 使用举例 

//Java8之前，接口中只支持常量和抽象接口：
public interface TestInterface{
    void test();
    abstract void test2();
}
//接口中的方法默认是abstract，可写可不写。

//从Java8开始支持default和static方法：

public interface TestInterface2{
    default void test3(){
        System.out.println("this is a default method");
    }

    static void test4(){
        System.out.println("this is a static method");
    }

}

//default方法可以被重写，而static方法不能被重写。
//具体要不要重写default方法，可以根据个人需求来。

//Java 9中除了支持default和static方法，还多了另外两个——private 和private static:
public interface PrivateInterface {
    void test();

    abstract void test2();

        default void test3() {
            System.out.println("default method");
            test5();
    }

    static void test4() {
        System.out.println("static method");
        test6();
    }

    private void test5() {
         System.out.println("private method");   
        test6();

    }

    private static void test6() {
        System.out.println("private static method");
    }
}

//private和private static方法都不能override，出现它们是为了提高代码利用率，更美观。
//区别就是private方法是为default方法服务的，private static 则是为static方法服务的。
//default方法可以调用abstract/private/static/private static方法。
//而static方法只能调用static/private static方法。

 

/**
 * Created by songhongkang on 2017/12/29 0029.
 * 1.
 * 类：人
 * 接口：兽  --->半兽人
 *
 * 2. 面试题：抽象类 和 接口的异同？
 *   ①二者的定义： a.声明的方式   b.内部的结构（jdk 7 ;jdk 8 ; jdk 9)
 *   ②共同点：不能实例化；以多态的方式使用
 *   ③不同点：单继承 ； 多实现
 */

interface MyInterface{
    //jdk 7 : 只能声明全局常量(public static final)和抽象方法(public abstract)
   abstract void method1();
    // jdk 8 : 增加了  声明静态方法 和 默认方法
    public static void method2(){
        System.out.println("method2");
    }
    default void method3(){
        System.out.println("method3");
    }
//前面的方法 虽然没有显示加上 public修饰符，但是他们默认是有的 全都是公共属性对外暴露

    //jdk9  增加了  方法可以私有化
//    jdk 9 : 声明私有方法
    private void method4(){
        System.out.println("私有方法");
    }
}

public class MyInterfaceImpl implements MyInterface {
    //这个必须实现
    @Override
    public void method1() {
        System.out.println("实现接口中的抽象方法 method1()");
    }

    public static void main(String[] args){
        MyInterfaceImpl imp = new MyInterfaceImpl();
        imp.method1();//调用抽象方法
        MyInterface.method2();//调用静态方法 静态方法不可以通过对象来调用了
        imp.method3();//调用默认方法
//        imp.method4();  接口的私有方法 不可以调用
    }
}

 实现接口中的抽象方法 method1()
method2
method3

 

---

6. 语法改进:钻石操作符(Diamond Operator)使用升级 

6.1 使用说明 

我们将能够与匿名实现类共同使用钻石操作符（diamond operator） 在 java 8 中如下的操作是会报错的： 

在 jdk1.8 的情况下是不可以的：

编译报错信息：'<>' cannot be used with anonymous classes 

6.2 使用举例 

jdk1.9:

import org.junit.Test;
import java.util.HashSet;
import java.util.Set;
public class DiamondOperatorTest {
    @Test
    public void testDiamondOperator(){
        diamondOperator();
    }

    public void diamondOperator(){
        //创建一个继承于HashSet的匿名子类的对象
        Set set = new HashSet<>(){};//编译通过
        set.add("MM");
        set.add("JJ");
        set.add("GG");
        set.add("DD");
        for(String s : set){
            System.out.println(s);
        }
    }
}

 

---

7. 语法改进：try 语句 

7.1 使用举例 

在 java 8 之前，我们习惯于这样处理资源的关闭： 

//举例1：
@Test
public void testTry1(){
    InputStreamReader reader = null;
    try{
        reader  = new InputStreamReader(System.in);
        //读取数据的过程：略
        reader.read();
    }catch (IOException e){
        e.printStackTrace();
    }finally{
        //资源的关闭操作
        if(reader != null){
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

java 8 中，可以实现资源的自动关闭，但是要求执行后必须关闭的所 有资源必须在 try 子句中初始化，否则编译不通过。如下例所示： 

//举例2：在举例1基础上，升级的写法。不用显式的处理资源的关闭
//java 8 中：要求资源对象的实例化，必须放在try的一对()内完成。
@Test
public void testTry2(){
    try(InputStreamReader reader = new InputStreamReader(System.in)){
        //读取数据的过程：略
        reader.read();
    }catch(IOException e){
        e.printStackTrace();
    }
}

 java 9 中，用资源语句编写 try 将更容易，我们可以在 try 子句中使用 已经初始化过的资源，此时的资源是 final 的： 

//如下的操作不可以在jdk 8 及之前的版本中使用
//java 9 中：可以在try()中调用已经实例化的资源对象
@Test
public void testTry3(){
    InputStreamReader reader = new InputStreamReader(System.in);
    OutputStreamWriter writer = new OutputStreamWriter(System.out);
    try(reader;writer){//多个资源用 ; 隔开即可
        //此时的reader是final的，不可再被赋值
//            reader = null;
        //读取数据的过程：略
        reader.read();
    }catch(IOException e){
        e.printStackTrace();
    }
}

 

---

8. 语法改进：UnderScore(下划线)使用的限制 

8.1 使用说明 

在 java 8 中，标识符可以独立使用“_”来命名： 

//在 java 8 中，
// 标识符可以独立使用“_”来命名： 
@Test
public void test(){
    String _ = "hello";
    System.out.println(_);
}

但是，在 java 9 中规定“_”不再可以单独命名标识符了，如果使用， 会报错： 

 

---

9. String 存储结构变更 

9.1 官方 Feature 

JEP 254: Compact Strings 

9.2 产生背景 

Motivation

The current implementation of the String class stores characters in a char array, using two bytes (sixteen bits) for each character. Data gathered from many different applications indicates that strings are a major component of heap usage and, moreover, that most String objects contain only Latin-1 characters. Such characters require only one byte of storage, hence half of the space in the internal char arrays of such String objects is going unused. 

动机

string类的当前实现将字符存储在char数组中，每个字符使用两个字节（16位）。从许多不同的应用程序收集的数据表明，字符串是堆使用的主要组成部分，而且，大多数字符串对象只包含拉丁-1字符。这样的字符只需要一个字节的存储空间，因此这样的字符串对象的内部字符数组中的一半空间将被闲置。

9.3 使用说明 

Description

We propose to change the internal representation of the String class from a UTF-16 char array to a byte array plus an encoding-flag field. The new String class will store characters encoded either as ISO-8859-1/Latin-1 (one byte per character), or as UTF-16 (two bytes per character), based upon the contents of the string. The encoding flag will indicate which encoding is used. 

描述

我们建议将字符串类的内部表示形式从UTF-16字符数组更改为字节数组加上编码标志字段。新的字符串类将根据字符串的内容存储编码为ISO-8859-1/Latin-1（每个字符一个字节）或UTF-16（每个字符两个字节）的字符。编码标志将指示使用哪种编码。

结论：String 再也不用 char[] 来存储啦，改成了 byte[] 加上编码标 记，节约了一些空间。 

 

 

9.4 拓展：StringBuffer 与 StringBuilder 

那 StringBuffer 和 StringBuilder 是否仍无动于衷呢？ 

String-related classes such as AbstractStringBuilder, StringBuilder, and StringBuffer will be updated to use the same representation, as will the HotSpot VM's intrinsic string operations. 

与字符串相关的类（如abstractStringBuilder、StringBuilder和StringBuffer）将更新为使用相同的表示，Hotspot VM的内部字符串操作也将更新。

 他们也是一样的变化的

String：jdk 8 及之前：底层使用char[]存储；jdk 9 : 底层使用byte[] (encoding flag)
StringBuffer:jdk 8 及之前：底层使用char[]存储；jdk 9 : 底层使用byte[]
StringBuilder:jdk 8 及之前：底层使用char[]存储；jdk 9 : 底层使用byte[]

String：不可变的字符序列；
StringBuffer:可变的字符序列；线程安全的，效率低；
StringBuilder:可变的字符序列；线程不安全的，效率高（jdk 5.0)

---

10. 集合工厂方法：快速创建只读集合 

10.1 官方 Feature 

269: Convenience Factory Methods for Collections 

10.2 产生背景 

要创建一个只读、不可改变的集合，必须构造和分配它，然后添加元 素，最后包装成一个不可修改的集合。

比如： 

//jdk 8 以及之前：创建一个只读特点的集合
@Test
public void test1(){
    List list = new ArrayList<>();
    list.add("Tom");
    list.add("Jerry");
    list.add("Lilei");
    list.add("HanMeimei");

    //调用Collections中的方法，将list变为只读的
    List newList = Collections.unmodifiableList(list);
//        newList.add("Tim");//不能执行，否则报异常
    //遍历：jdk 8
    newList.forEach(System.out::println);
}

@Test
public void test(){
    List list = Arrays.asList(1, 2, 3); //创建的是一个只读的集合
    list.add(4);
}

缺点：我们一下写了五行。即：它不能表达为单个表达式。 
当然，我们也可以稍微简单点处理： 

//jdk 8 以及之前：创建一个只读特点的集合
@Test
public void test2(){
    //List:
    List list = Collections.unmodifiableList(Arrays.asList(1, 2, 3));
//        list.add(4);
    //Set:
    Set set = Collections.unmodifiableSet(new HashSet<>(Arrays.asList(1, 2, 3)));
//        set.add(4);
//        set.forEach(System.out::println);

    //Map:
    //如下操作不适用于jk8及之前版本，适用于jdk9
    Map map = Collections.unmodifiableMap(new HashMap<>() {//java9 才可以这样
        {
            put("Tom", 78);
            put("Jerry", 88);
            put("Tim", 68);
        }
    });
    map.forEach((k,v) -> System.out.println(k + ":" + v));
}

10.3 使用说明

Java 9 因此引入了方便的方法，这使得类似的事情更容易表达。 

package java.util;
import java.util.function.UnaryOperator;
public interface List extends Collection {
    //------------省略--------
    static  List of() {
        return ImmutableCollections.List0.instance();
    }
    static  List of(E e1) {
        return new ImmutableCollections.List1<>(e1);
    }
    static  List of(E e1, E e2) {
        return new ImmutableCollections.List2<>(e1, e2);
    }

    static  List of(E e1, E e2, E e3) {
        return new ImmutableCollections.ListN<>(e1, e2, e3);
    }
    static  List of(E e1, E e2, E e3, E e4) {
        return new ImmutableCollections.ListN<>(e1, e2, e3, e4);
    }
    static  List of(E e1, E e2, E e3, E e4, E e5) {
        return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5);
    }
    static  List of(E e1, E e2, E e3, E e4, E e5, E e6) {
        return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
                                                e6);
    }

    static  List of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
        return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
                                                e6, e7);
    }
    static  List of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
        return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
                                                e6, e7, e8);
    }
    static  List of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
        return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
                                                e6, e7, e8, e9);
    }
    static  List of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {
        return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
                                                e6, e7, e8, e9, e10);
    }
}

List firsnamesList = List.of(“Joe”,”Bob”,”Bill”);  

调用集合中静态方法 of()，可以将不同数量的参数传输到此工厂方法中。此功能可用于 Set 和 List，也可用于 Map 的类似形式。此时得到 的集合，是不可变的：在创建后，继续添加元素到这些集合会导致 “UnsupportedOperationException”

由于 Java 8 中接口方法的实现，可以直接在 List，Set 和 Map 的接口 内定义这些方法，便于调用。 

10.4 使用举例 

//jdk 9 中：创建一个只读特点的集合
@Test
public void test3(){
    //List:
    List list = List.of(1, 2, 3);
//        list.add(4);
    list.forEach(System.out::println);
    //Set:
    Set set = Set.of(2, 3, 4);
//        set.add(6);
    
    //Map:
    //创建只读集合的方式一：
    Map map = Map.of("Tom", 23, "Jerry", 22, "Lilei", 12, "HanMeimei", 18);
//        map.put("Tim",33);
    
    //创建只读集合的方式二：
    Map map1 = Map.ofEntries(Map.entry("Tom", 23), Map.entry("Jerry", 21));
//        map1.put("Tim",33);
    System.out.println(map1);
}

---

11. 增强的 Stream API 

11.1 使用说明 

Java 的 Steam API 是java标准库最好的改进之一，让开发者能够 快速运算，从而能够有效的利用数据并行计算。Java 8 提供的 Steam 能够利用多核架构实现声明式的数据处理。

在 Java 9 中，Stream API 变得更好，Stream 接口中添加了 4 个 新的方法：dropWhile, takeWhile, ofNullable，还有个 iterate 方法的 新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时 候结束迭代。（见下例） 

 除了对 Stream 本身的扩展，Optional 和 Stream 之间的结合也 得到了改进。现在可以通过 Optional 的新方法 stream() 将一个 Optional 对象转换为一个(可能是空的) Stream 对象。（见下例） 

11.2 使用举例 

takeWhile()的使用：

用于从 Stream 中获取一部分数据，接收一个 Predicate 来进行选择。在有序的 Stream 中，takeWhile 返回从开头开始的尽量多的元素。 

//1.takeWhile()
@Test
public void test1(){
    List list = Arrays.asList(45,56,33,77,44,98,76,78,33);
    Stream stream = list.stream();
    stream.takeWhile(x -> x < 70).forEach((x)->{System.out.print(x+" ");});

    System.out.println("\n--------------------------");
    List list1 = Arrays.asList(1,2,3,4,5,6,7,8);
    list1.stream().takeWhile(x -> x < 5).forEach((x)->{System.out.print(x+" ");});
}

输出： 

45 56 33 
--------------------------
1 2 3 4 

 注意：这个和 filter 是不同的，他是从开头找，凡是有一个不满足就结束了。

 

dropWhile()的使用：

dropWhile 的行为与 takeWhile 相反，返回剩余的元素。 

//2.dropWhile():与 takeWhile() 整好相反
@Test
public void test2(){
    List list = Arrays.asList(45,56,33,77,44,98,76,78,33);
    Stream stream = list.stream();
    stream.dropWhile(x -> x < 70).forEach((x)->{System.out.print(x+" ");});

    System.out.println("\n--------------------------");
    List list1 = Arrays.asList(1,2,3,4,5,6,7,8);
    list1.stream().dropWhile(x -> x < 5).forEach((x)->{System.out.print(x+" ");});
}

 77 44 98 76 78 33 
--------------------------
5 6 7 8  

takeWhile() + dropWhile() 就是一个完整的流

 

ofNullable()的使用：

Java 8 中 Stream 不能完全为 null（一个元素不能为 null 多个元素是可以存在 null ），否则会报空指针异常。而 Java 9 中的 ofNullable 方法允许我们创建一个单元素 Stream，可以包含一个非空元素，也可 以创建一个空 Stream。 

//3.ofNullable(T t): t可以为null
@Test
public void test3(){
    // 不报异常，允许通过 
    Stream stream1 = Stream.of(1, 2, 3, null);
    stream1.forEach(System.out::println);

    // 不报异常，允许通过 
    List list = new ArrayList<>(); 
    list.add("AA"); 
    list.add(null); 
    System.out.println(list.stream().count());//2 
    System.out.println("------------------------------");

//如果只有单个元素，此元素不能为null.否则报NullPointerException
//        Stream