模块化系统，jShell命令

1. 官方文档

官方提供的新特性列表:

https://docs.oracle.com/javase/9/whatsnew/toc.htm#JSNEW-GUID-C23AFD78-C777-460B-8ACE-58BE5EA681F6
Open JDK

http://openjdk.java.net/projects/jdk9/
在线Oracle JDK 9 Documentation

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

2. 文件目录改变

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

3. 模块化系统

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

Java 运行环境的膨胀和臃肿。每次JVM启动的时候，至少会有30~60MB的内存加载，主要原因是JVM需要加载rt.jar，不管其中的类是否被classloader加载，第一步整个jar都会被JVM加载到内存当中去(而模块化可以根据模块的需要加载程序运行需要的class)
当代码库越来越大，创建复杂，盘根错节的“意大利面条式代码”的几率呈指数级的增长。不同版本的类库交叉依赖导致让人头疼的问题，这些都阻碍了 Java 开发和运行效率的提升。
很难真正地对代码进行封装, 而系统并没有对不同部分(也就是 JAR 文件)之间的依赖关系有个明确的概念。每一个公共类都可以被类路径之下任何其它的公共类所访问到，这样就会导致无意中使用了并不想被公开访问的 API。
本质上讲也就是说，用模块来管理各个package，通过声明某个package 暴露，，模块(module)的概念，其实就是package外再裹一层，不声明默认就是隐藏。因此，模块化使得代码组织上更安全，因为它可以指定哪些部分可以暴露，哪些部分隐藏
实现目标
- 模块化的主要目的在于减少内存的开销
- 只须必要模块，而非全部jdk模块，可简化各种类库和大型应用的开发和维护
- 改进 Java SE 平台，使其可以适应不同大小的计算设备
- 改进其安全性，可维护性，提高性能
模块将由通常的类和新的模块声明文件(module-info.java)组成。该文件是位于 java代码结构的顶层，该模块描述符明确地定义了我们的模块需要什么依赖关系，以及哪些模块被外部使用。在exports子句中未提及的所有包默认情况下将封装在模块中，不能在外部使用

要想在A模块中调用B模块下包中的结构，需要在B的module-info.java中声明
1
2
3
4
module B {
//package we export
exports com.runaccepted.bean;
}
exports：控制着哪些包可以被其它模块访问到。所有不被导出的包默认都被封装在模块里面。

对应在A模块的src下创建module-info.java文件:
1
2
3
module A {
requires java9test;
}
requires：指明对其它模块的依赖。

4. jShell命令

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

即写即得、快速运行
实现目标
- Java 9 中终于拥有了 REPL工具:jShell。让Java可以像脚本语言一样运行，从控制台启动jShell，利用jShell在没有创建类的情况下直接声明变量，计算表达式，执行语句。即开发时可以在命令行里直接运行Java的代码，而无需创建Java文件，无需跟人解释”public static void main(String[] args)”这句废话。
- jShell也可以从文件中加载语句或者将语句保存到文件中。
- jShell也可以是tab键进行自动补全和自动添加分号。

4.1. 操作

访问：/Library/Java/JavaVirtualMachines/jdk-9.0.4.jdk/Contents/Home/bin/

基本操作

5. 语法改进

5.1. 接口的私有方法

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

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

interface MyInterface {
    void normalInterfaceMethod();
		default void methodDefault1(){ 
      init();
		}
		public default void methodDefault2(){ 
      init();
		}
 
		// This method is not part of the public API exposed by MyInterface
		private void init(){ 
      System.out.println("默认方法中的通用操作");
		}
}

class MyInterfaceImpl implements MyInterface {
		@Override
		public void normalInterfaceMethod(){ 
      System.out.println("实现接口的方法");
    } 
}

public class MyInterfaceTest {
    public static void main(String[] args) {
      MyInterfaceImpl impl = new MyInterfaceImpl(); 
      impl.methodDefault1();
      // impl.init();//不能调用
	  } 
}

5.2. 钻石操作符使用升级

将能够与匿名实现类共同使用钻石操作符(diamond operator)在Java 8中如下的操作是会报错的:

//编译报错信息:Cannot use “<>” with anonymous inner classes.
Comparator<Object> com = new Comparator<>(){
	@Override
  public int compare(Object o1, Object o2) { 
    return 0;
	} 
};

Java 9中如下操作可以正常执行通过:

// anonymous classes can now use type inference
Comparator<Object> com = new Comparator<>(){
  @Override
  public int compare(Object o1, Object o2) { 
    return 0;
	} 
};

5.3. try语法

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

try(InputStreamReader reader = new InputStreamReader(System.in)){ 
  //读取数据细节省略
}catch (IOException e){ 
  e.printStackTrace();
}

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

InputStreamReader reader = new InputStreamReader(System.in); 
OutputStreamWriter writer = new OutputStreamWriter(System.out); 
try (reader; writer) {
  //reader是final的，不可再被赋值 
  //reader = null; 
  //具体读写操作省略
} catch (IOException e) { 
  e.printStackTrace();
}

5.4. String存储结构变更

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.

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.

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

1
2
3

public final class String implements java.io.Serializable, Comparable<String>, CharSequence { @Stable
 private final byte[] value;
}

那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.

5.5. 快速创建只读集合

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

List<String> namesList = new ArrayList <>(); 
namesList.add("Joe"); 
namesList.add("Bob"); 
namesList.add("Bill");

namesList = Collections.unmodifiableList(namesList); 
System.out.println(namesList);

缺点:我们一下写了五行。即:它不能表达为单个表达式。

List<String> list = Collections.unmodifiableList(Arrays.asList("a", "b", "c")); Set<String> set = Collections.unmodifiableSet(new HashSet<>(Arrays.asList("a", "b", "c")));
// 如下操作不适用于jdk 8 及之前版本,适用于jdk 9
Map<String, Integer> map = Collections.unmodifiableMap(new HashMap<>() { 
  {
				put("a", 1); 
        put("b", 2); 
        put("c", 3);
 }
});
map.forEach((k, v) -> System.out.println(k + ":" + v));

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

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

List<String> list = List.of("a", "b", "c"); 
Set<String> set = Set.of("a", "b", "c");

Map<String, Integer> map1 = Map.of("Tom", 12, "Jerry", 21, "Lilei", 33, "HanMeimei", 18);
Map<String, Integer> map2 = Map.ofEntries(Map.entry("Tom", 89), Map.entry("Jim", 78), Map.entry("Tim", 98));

5.6. InputStream 加强

InputStream 终于有了一个非常有用的方法：transferTo，可以用来将数据直接传输到 OutputStream，这是在处理原始数据流时非常常见的一种用法，如下示例。

ClassLoader cl = this.getClass().getClassLoader();
try (InputStream is = cl.getResourceAsStream("hello.txt");
OutputStream os = new FileOutputStream("src\\hello1.txt")){ 
  is.transferTo(os); // 把输入流中的所有数据直接自动地复制到输出流中
} catch (IOException e) { 
  e.printStackTrace();
}

6. 增强的 Stream API

Java 的 Steam API 是java标准库最好的改进之一，让开发者能够快速运算，从而能够有效的利用数据并行计算。Java 8 提供的 Steam 能够利用多核架构实现声明式的数据处理。
在 Java 9 中，Stream API 变得更好，Stream 接口中添加了 4 个新的方法: takeWhile, dropWhile, ofNullable，还有个 iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代。
除了对 Stream 本身的扩展，Optional 和 Stream 之间的结合也得到了改进。现在可以通过 Optional 的新方法 stream() 将一个 Optional 对象转换为一个 (可能是空的) Stream 对象。

6.1. takeWhile()的使用

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

List<Integer> list = Arrays.asList(45, 43, 76, 87, 42, 77, 90, 73, 67, 88); 
//45 43
list.stream().takeWhile(x -> x < 50).forEach(System.out::println);
System.out.println();
list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
//1 2 3 4
list.stream().takeWhile(x -> x < 5).forEach(System.out::println);

6.2. dropWhile()的使用

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

List<Integer> list = Arrays.asList(45, 43, 76, 87, 42, 77, 90, 73, 67, 88); 
//76  87  42  77  90  73  67 88
list.stream().dropWhile(x -> x < 50).forEach(System.out::println);
System.out.println();
list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
//6 7 8
list.stream().dropWhile(x -> x < 5).forEach(System.out::println);

6.3. ofNullable()的使用

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

// 报NullPointerException
// Stream<Object> stream1 = Stream.of(null);
// System.out.println(stream1.count());
// 不报异常，允许通过
Stream<String> stringStream = Stream.of("AA", "BB", null); System.out.println(stringStream.count());// 3
// 不报异常，允许通过
List<String> list = new ArrayList<>();
list.add("AA");
list.add(null); System.out.println(list.stream().count());// 2
// ofNullable():允许值为null
Stream<Object> stream1 = Stream.ofNullable(null); 
System.out.println(stream1.count());// 0
Stream<String> stream = Stream.ofNullable("hello world"); System.out.println(stream.count());// 1

6.4. iterate()重载的使用

这个 iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代。

// 原来的控制终止方式:
 Stream.iterate(1, i -> i + 1).limit(10).forEach(System.out::println);
 // 现在的终止方式:
 Stream.iterate(1, i -> i < 100, i -> i + 1).forEach(System.out::println);

6.5. Optional类中stream()的使用

List<String> list = new ArrayList<>(); list.add("Tom");
 list.add("Jerry");
 list.add("Tim");

Optional<List<String>> optional = Optional.ofNullable(list); 
Stream<List<String>> stream = optional.stream(); 
stream.flatMap(x -> x.stream()).forEach(System.out::println);

7. Javascript引擎升级:Nashorn

Nashorn 项目在 JDK 9 中得到改进，它为 Java 提供轻量级的 Javascript 运行时。 Nashorn 项目跟随 Netscape 的 Rhino 项目，目的是为了在 Java 中实现一个高性能但轻量级的 Javascript 运行时。Nashorn 项目使得 Java 应用能够嵌入 Javascript。它在 JDK 8 中为 Java 提供一个 Javascript 引擎。
JDK 9 包含一个用来解析 Nashorn 的 ECMAScript 语法树的 API。这个 API 使得 IDE 和服务端框架不需要依赖 Nashorn 项目的内部实现类，就能够分析 ECMAScript 代码。

W.T.的博客

Java基础知识-Java9新特性