关于java:JDK9的这些新特征你知道吗

• 模块化零碎
• jShell 命令
• 接口的公有办法
• 钻石操作符的应用降级
• 垃圾收集机制
• 语法改良：try 语句
• String 存储构造变更
• 创立只读汇合
• 加强的 Stream API

1，Java 平台模块化零碎：

引入了一种新的 Java 编程组件模块，它是一个命名的、自描述的代码和数据汇合。实质上说，模块（module）的概念，其实就是 package 外再包裹一层，也就是说，用模块来治理各个 package，通过申明某个 package 裸露，不申明默认就是暗藏。因而模块化是的代码组织上更平安，因为它能够指定哪些局部裸露，哪些局部暗藏。

过程：

① 创立一个 java9demo 的工程，而后在这个工程上面创立 2 个 module。一个 java9A，一个 java9B。

② 在 java9A 中创立一个实体类 Person，而后想在 java9B 中援用它，失常状况下是援用不到的，因为是存在两个模块中。

③ 咱们在 java9A 模块的 src 目录下新建 module-info.java 文件(这个文件就是所谓的模块化文件)

module java9A {
 // 这里 exports 前面跟具体的包名
 exports com.hepingfly.bean;
}

④ 咱们在 java9B 模块的 src 目录下新建 module-info.java 文件

module java9demo {
 // requires 前面跟具体要引入的 module 的名字
 requires java9A;
}

⑤ 这样在 java9B 模块中就能援用 java9A 模块裸露进去的实体类了。

public class ModuleTest {
 // 我在 java9B 模块中想援用 java9A 模块中的 Person 类
 public static void main(String[] args) {Person person = new Person();
        person.setName("hepingfly");
        System.out.println(person.getName());   // 打印 hepingfly
    }
}

模块化零碎是基于 jar 包 和类 之间存在的，目标在于尽可能的缩小 jar 中多余类的加载，保障整体我的项目运行时的效率，对于我的项目运行必定有肯定的积极意义。

2、JShell：

它示意 Java Shell，是大家熟知的 REPL (读取 - 执行 - 打印 - 循环) 模式。利用 jshell 能够在没有创立类的状况下间接申明变量，计算表达式，执行语句。即开发时能够在命令行里间接运行 Java 代码，无需创立 Java 文件。

根本应用：

① JDK9 以上的版本如果你配置好了环境变量间接在命令行输出 jshell 即可进入交互界面起因是 JDK 的 bin 目录下有 jshell 这个工具）

② 输出命令取得帮忙信息
【jshell> /help intro】输出 /help intro 取得一些帮忙信息

③ 定义变量，计算变量值

④ 定义方法，调用办法

⑤ 导入指定的包
【jshell> import java.util.*】能够通过 import 命令导入指定的包
【jshell> /imports】查看默认导入了哪些包

⑥ 列出以后 session 内所有无效的代码片段
【jshell> /list】判断以后 session 内所有无效的代码片段

⑦ 查看以后 session 下所有创立过的变量
【jshell> /var】

⑧ 查看以后 session 下所有创立过的办法
【jshell> /methods】

⑨ 从内部文件加载源代码

源代码：

// hello.java 文件中的内容
public void hello() {System.out.println("hello hepingfly");
}
hello();

⑩ 退出 jshell
【jshell> /exit】

注：

• jshell 能够应用 tab 键进行主动补全
• jshell 能够从文件中加载语句或者将语句保留到文件中
• 在 jshell 中定义雷同办法名和参数列表的办法，即为对现有办法的笼罩。
• 在 jshell 中你会发现不会呈现编译时异样，因为 jshell 帮你暗藏了。

3, 接口的公有办法:

jdk9，容许在接口中应用公有办法。在 Java9 中，接口更加灵便和弱小，办法的拜访权限修饰符能够申明为 private 的了，此时办法将不会成为你对外裸露的 API 的一部分。

//jdk9：申明公有办法
private void method4(){System.out.println("公有办法");
}

4, 钻石操作符的应用降级

java9 增加了匿名外部类的性能 前面增加了大括号{} 能够做一些细节的操作

Map<String,String> map9 = new HashMap<>(){};

5, 垃圾收集机制

Java 9 移除了在 Java 8 中 被废除的垃圾回收器配置组合（DefNew + CMS，ParNew + SerialOld，Incremental CMS）

同时把 G1 设为默认的垃圾回收器实现。代替了之前默认应用的 Parallel GC

JVM 有了对立的日志记录零碎，能够应用新的命令行选项 -Xlog 来管制 JVM 上 所有组件的日志记录。该日志记录零碎能够设置输入的日志音讯的标签、级别、修饰符和输入指标等。

6, 语法改良：try 语句

在 Java9 中能够在 try 子句中应用曾经初始化过的资源。

 public void testJava() {
         /**
          * 能够在 try 前面的小括号中调用曾经实例化好的资源对象
          * 多个资源对象以分号分隔
          */
         InputStreamReader is = new InputStreamReader(System.in);
         OutputStreamWriter os = new OutputStreamWriter(System.out);
         try (is;os) {System.out.println(is.read());
         } catch (Exception e) {e.printStackTrace();
         }
     }

7,String 存储构造变更

String 的实现底层由 char[] 改为 byte[]，存储效率变高，调用效率同样变高

@Stable
private final byte[] value;

8, 创立只读合集

public static void testJava() {
    // 创立一个只读的 list
    List<String> list = List.of("heping", "fly");
    // 创立一个只读的 set
    Set<String> set = Set.of("heping", "fly");
    // 创立一个只读的 map
    Map<String, String> map = Map.of("name", "heping", "age", "18");
    Map<String, String> map2 = Map.ofEntries(Map.entry("name", "heping"), Map.entry("age", "12"));
}

9, 加强的 Stream API

在 Java9 中，Stream API 变的更好，Stream 接口中增加了 4 个新的办法，dropWhile、takeWhile、ofNullable、还有个 iterator 办法的新重载办法。

• takeWhile : 用于从 Stream 中获取一部分数据，接管一个 predicate 来进行抉择。在有序的 Stream 中，takeWhile 返回从结尾开始的尽量多的元素。

  public static void test1() {List<Integer> list = Arrays.asList(13,11,45,18,20,16,96);
      Stream<Integer> stream = list.stream();
      stream.takeWhile((x) -> x < 20).forEach(System.out::println);
  }

• dropWhile: 与 takeWhile() 整好相同，dropWhile 返回残余的元素。

  public static void test2() {List<Integer> list = Arrays.asList(13,11,45,18,20,16,96);
      Stream<Integer> stream = list.stream();
      stream.dropWhile((x) -> x < 20).forEach(System.out::println);
  }

• ofNullable : 能够蕴含一个非空元素，也能够创立一个空 Stream。

  public static void test3() {Stream<Integer> stream = Stream.of(1, 2, 3, null);
      stream.forEach(System.out::println);
      // 如果只有单个元素，此元素不能为 null, 否则报空指针异样
      Stream<Object> stream1 = Stream.of(null);
      // Java9 新增 ofNullable 容许单个元素为空
      Stream<Object> stream2 = Stream.ofNullable(null);
      System.out.println(stream2.count());   // 0
  }

• iterate：重载的办法

    public static void test4() {
    // 须要通过 limit 来管制终止
    Stream.iterate(0, x -> x + 1).limit(10).forEach(System.out::println);
    // 这里就能够通过传入一个断言型函数来进行终止
    Stream.iterate(0, x -> x < 10, x -> x + 1).forEach(System.out::println);
    }