执行的结果和错误都会立即显示在控制台上#

可以直接创建一个方法并调用#

可以覆盖方法#

1
jshell> String quintic(String a){
2
   ...> return "Know:" + a;
3
   ...> }
4
|  已修改 方法 quintic(String)
5
|    更新已覆盖 方法 quintic(String)
6

7
jshell> quintic("Base");
8

9
$9 ==> "Know:Base"
10
|  已创建暂存变量 $9 : String
11

12
jshell>

模块化系统是目的#

以下我对相关资料的理解和总结，仅代表个人理解

• 为了使jar相互之前依赖有限制，虽然java已经有public、private、protected、default修饰符保证类的可见性，但是对于jar来说，相互之间的依赖基本是开放的，为了使一个项目依赖有限制，Java 9引入了模块化系统。即使是public的类，没有export时，也是无法被其他jar访问的

• 模块化可以解决循环依赖偶合的问题

• 我们一定遇到过，想要引入一个类时，两个jar中包含了有相同的类（也有相同的包名），大多数的编译器可能会报错，但是我也遇到没有报错的情况，所以你import的类，有可能不是你想要的那个，这种情况我也是遇到过的，我没有仔细研究过这个问题，可能和jvm有关系，模块化也可以解决这个重复问题。

• 解决运行时才报类找不到的问题，这种情况虽然大部分集成开发环境都有编译错误，但是难保一种情况就是你提交到生产环境时忘记提交关键的jar包，导致运行时找不到类。你们一定遇到过，启动时不报错，但是调到那个功能时才报错的情况。这种可以算是重大失误，因为重大项目的生产环境的部署是需要多个经理批准的，如果因为这种人为失误导致，需要重新提交release批准，那可麻烦了。

quick start#

1
module com.greetings { }

1
 package com.greetings;
2
    public class Main {
3
        public static void main(String[] args) {
4
            System.out.println("Greetings!");
5
        }
6
    }

1
javac -d mods/com.greetings \
2
        src/com.greetings/module-info.java \
3
        src/com.greetings/com/greetings/Main.java

1
java --module-path mods -m com.greetings/com.greetings.Main

模块之间的引入和导出#

我们将之前的包结构再增加一个模块叫“org.astro”

1
package org.astro;
2
    public class World {
3
        public static String name() {
4
                return "world";
5
        }
6
    }

1
module org.astro {
2
        exports org.astro;
3
}

1
module com.greetings {
2
    requires org.astro;
3
}

1
demo\src\com.greetings\com\greetings\Main.java

1
 package com.greetings;
2
 import org.astro.World;
3
    public class Main {
4
        public static void main(String[] args) {
5
            System.out.format("Greetings %s!%n", World.name());
6
        }
7
    }

一次编译多个模块#

1
javac -d mods --module-source-path src  src/org.astro/module-info.java ^
2
src/org.astro/org/astro/World.java ^
3
 src/com.greetings/module-info.java ^
4
 src/com.greetings/com/greetings/Main.java

如果在klinux bash环境中更好，直接用命令组合一次编译所有java模块

1
javac -d mods --module-source-path src $(find src -name "*.java")

生成modular jar#

指定编译目录和输出jar的目录

1
jar --create --file=mlib/org.astro@1.0.jar  --module-version=1.0 -C mods/org.astro .
2

3
jar --create --file=mlib/com.greetings.jar  --main-class=com.greetings.Main -C mods/com.greetings .

可以直接执行jar而不需要指定main class

1
 java -p mlib -m com.greetings

可以通过命令看到模块jar的信息

1
jar --describe-module --file=mlib/org.astro@1.0.jar

没有exports和requires的申明会怎么样呢？#

模块中的服务(Services)#

这次的示例会创建”com.socket”和”com.fastsocket”两个模块，来展示模块中服务的应用，并通过”org.greetings”模块来调用”com.socket”和”com.fastsocket”中的服务。

简单来说，有点像MVC模式，MVC模式中，M是model，V是view，C是controller，而MVC模式中，M是service，V是UI，C是controller。以前的实现是直接一个包里面使用接口加实现类的方式，实现一个服务功能，但是模块化之后，抽象和实现分离，分别作为两个不同模块，抽象作为API用于controller调用，controller也可以是一个模块，或者main方法入口吧。

1
    module com.socket {
2
        exports com.socket;
3
        exports com.socket.spi;
4
        uses com.socket.spi.NetworkSocketProvider;
5
    }

1
    package com.socket;
2

3
    import java.io.Closeable;
4
    import java.util.Iterator;
5
    import java.util.ServiceLoader;
6

7
    import com.socket.spi.NetworkSocketProvider;
8

9
    public abstract class NetworkSocket implements Closeable {
10
        protected NetworkSocket() { }
11

12
        public static NetworkSocket open() {
13
            ServiceLoader<NetworkSocketProvider> sl
14
                = ServiceLoader.load(NetworkSocketProvider.class);
15
            Iterator<NetworkSocketProvider> iter = sl.iterator();
16
            if (!iter.hasNext())
17
                throw new RuntimeException("No service providers found!");
18
            NetworkSocketProvider provider = iter.next();
19
            return provider.openNetworkSocket();
20
        }
21
    }

1
    package com.socket.spi;
2

3
    import com.socket.NetworkSocket;
4

5
    public abstract class NetworkSocketProvider {
6
        protected NetworkSocketProvider() { }
7

8
        public abstract NetworkSocket openNetworkSocket();
9
    }

1
    module org.fastsocket {
2
        requires com.socket;
3
        provides com.socket.spi.NetworkSocketProvider
4
            with org.fastsocket.FastNetworkSocketProvider;
5
    }

1
    package org.fastsocket;
2

3
    import com.socket.NetworkSocket;
4
    import com.socket.spi.NetworkSocketProvider;
5

6
    public class FastNetworkSocketProvider extends NetworkSocketProvider {
7
        public FastNetworkSocketProvider() { }
8

9
        @Override
10
        public NetworkSocket openNetworkSocket() {
11
            return new FastNetworkSocket();
12
        }
13
    }

1
    package org.fastsocket;
2

3
    import com.socket.NetworkSocket;
4

5
    class FastNetworkSocket extends NetworkSocket {
6
        FastNetworkSocket() { }
7
        public void close() { }
8
    }

1
    module com.greetings {
2
        requires com.socket;
3
    }

1
    package com.greetings;
2

3
    import com.socket.NetworkSocket;
4

5
    public class Main {
6
        public static void main(String[] args) {
7
            NetworkSocket s = NetworkSocket.open();
8
            System.out.println(s.getClass());
9
        }
10
    }

1
    $ mkdir mods
2
    $ javac -d mods --module-source-path src $(find src -name "*.java")

jlink#

jlink是JDK9提供的一个工具，用于生成一个自定义模块化的镜像，主要用于链接多个模块，并用于包含传递式依赖(如果有在生产环境手动运行过jar的朋友，应该会遇到需要命令行中引入多个jar，让在运行时可以互相找到对应jar包中的依赖)。

这个工具要求模块必须在模块路径中，并且被打包作为模块化JAR，或者JMOD模式。JDK在JMOD格式打包标准并且是JDK指定的模块。

1
# $JAVA_HOME/jmods是固定语句，是一个路径，用于包含模块化系统的jar包。本质上模块化系统的基础也是java实现的。需要一起整合。（ 里面有java.base.jmod 和其他标准包或者JDK模块）
2
# mlib是你的模块路径，里面有你编译打包好的多模块
3
# 但是我这里--add-modules后面只指定一个模块，由于这个模块依赖了org.astro所以生成镜像时也会包含相关的依赖模块
4
#  --output是输出路径
5
jlink --module-path $JAVA_HOME/jmods:mlib --add-modules com.greetings --output greetingsapp
6

7
# 因为我的JAVA_HOME路径有空格，必须要用双引号包裹，而且由于我的环境是windows，所以分隔符必须用;
8
 jlink --module-path "$JAVA_HOME/jmods;mlib" --add-modules com.greetings --output greetingsapp

生成的应用，生成应用可以独立运行，无需安装 JDK

—patch-module#

这个应用是说可以对已经导出的模块进行修改，从名字也可以看到是打补丁的意思，这个不多描述了。 Developers that checkout java.util.concurrent classes from Doug Lea’s CVS will be used to compiling the source files and deploying those classes with -Xbootclasspath/p. -Xbootclasspath/p has been removed, its module replacement is the option —patch-module to override classes in a module. It can also be used to augment the contents of module. The —patch-module option is also supported by javac to compile code “as if” part of the module.

Here’s an example that compiles a new version of java.util.concurrent.ConcurrentHashMap and uses it at run-time:

1
javac --patch-module java.base=src -d mypatches/java.base \
2
    src/java.base/java/util/concurrent/ConcurrentHashMap.java
3

4
java --patch-module java.base=mypatches/java.base ...

集合#

• 增加了List.of()、Set.of()、Map.of() 和 Map.ofEntries()等工厂方法来创建不可变集合（有点参考 Guava 的味道）：

1
List.of("Java", "C++");
2
Set.of("Java", "C++");
3
Map.of("Java", 1, "C++", 2);

使用 of() 创建的集合为不可变集合，不能进行添加、删除、替换、 排序等操作，不然会报 java.lang.UnsupportedOperationException 异常。

Stream 增强#

ream 中增加了新的方法 ofNullable()、dropWhile()、takeWhile() 以及 iterate() 方法的重载方法。

Java 9 中的 ofNullable() 方 法允许我们创建一个单元素的 Stream，可以包含一个非空元素，也可以创建一个空 Stream 。 而在 Java 8 中则不可以创建空的 Stream 。

1
Stream<String> stringStream = Stream.ofNullable("Java");
2
System.out.println(stringStream.count());// 1
3
Stream<String> nullStream = Stream.ofNullable(null);
4
System.out.println(nullStream.count());//0

takeWhile() 方法可以从 Stream 中依次获取满足条件的元素，直到不满足条件为止结束获取。

1
List<Integer> integerList = List.of(11, 33, 66, 8, 9, 13);
2
integerList.stream().takeWhile(x -> x < 50).forEach(System.out::println);// 11 33

dropWhile() 方法的效果和 takeWhile() 相反。

1
List<Integer> integerList2 = List.of(11, 33, 66, 8, 9, 13);
2
integerList2.stream().dropWhile(x -> x < 50).forEach(System.out::println);// 66 8 9 13

iterate() 方法的新重载方法提供了一个 Predicate 参数 (判断条件)来决定什么时候结束迭代

1
public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) {
2
}
3
// 新增加的重载方法
4
public static<T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
5

6
}

两者的使用对比如下，新的 iterate() 重载方法更加灵活一些。

1
// 使用原始 iterate() 方法输出数字 1~10
2
Stream.iterate(1, i -> i + 1).limit(10).forEach(System.out::println);
3
// 使用新的 iterate() 重载方法输出数字 1~10
4
Stream.iterate(1, i -> i <= 10, i -> i + 1).forEach(System.out::println);

Optional 增强#

Optional 类中新增了 ifPresentOrElse()、or() 和 stream() 等方法

ifPresentOrElse() 方法接受两个参数 Consumer 和 Runnable ，如果 Optional 不为空调用 Consumer 参数，为空则调用 Runnable 参数。

1
public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction)
2

3
Optional<Object> objectOptional = Optional.empty();
4
objectOptional.ifPresentOrElse(System.out::println, () -> System.out.println("Empty!!!"));// Empty!!!

or() 方法接受一个 Supplier 参数 ，如果 Optional 为空则返回 Supplier 参数指定的 Optional 值。

1
public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier)
2

3
Optional<Object> objectOptional = Optional.empty();
4
objectOptional.or(() -> Optional.of("java")).ifPresent(System.out::println);//java

String 增强#

Java 8 及之前的版本，String 一直是用 char[] 存储。在 Java 9 之后，String 的实现改用 byte[] 数组存储字符串，节省了空间。

1
public final class String implements java.io.Serializable,Comparable<String>, CharSequence {
2
    // @Stable 注解表示变量最多被修改一次，称为"稳定的"。
3
    @Stable
4
    private final byte[] value;
5
}

接口增强#

Java 9 允许在接口中使用私有方法。这样的话，接口的使用就更加灵活了，有点像是一个简化版的抽象类。

1
public interface MyInterface {
2
    private void methodPrivate(){
3
    }
4
}

IO 增强#

在 Java 9 之前，我们只能在 try-with-resources 块中声明变量：

1
try (Scanner scanner = new Scanner(new File("testRead.txt"));
2
    PrintWriter writer = new PrintWriter(new File("testWrite.txt"))) {
3
    // omitted
4
}

在 Java 9 之后，在 try-with-resources 语句中可以使用 effectively-final 变量。

1
final Scanner scanner = new Scanner(new File("testRead.txt"));
2
PrintWriter writer = new PrintWriter(new File("testWrite.txt"));
3
try (scanner; writer) {
4
    // omitted
5
}

什么是 effectively-final 变量？ 简单来说就是没有被 final 修饰但是值在初始化后从未更改的变量。

正如上面的代码所演示的那样，即使 writer 变量没有被显示声明为 final，但它在第一次被赋值后就不会改变了，因此，它就是 effectively-final 变量。

进程 API Java 9 增加了 java.lang.ProcessHandle 接口来实现对原生进程进行管理，尤其适合于管理长时间运行的进程。

1
// 获取当前正在运行的 JVM 的进程
2
ProcessHandle currentProcess = ProcessHandle.current();
3
// 输出进程的 id
4
System.out.println(currentProcess.pid());
5
// 输出进程的信息
6
System.out.println(currentProcess.info());

ProcessHandle 接口概览：