Java9新特性

模块化技术

模块由通常的类和新的模块声明文件(module-info.java)组成。 该文件是位于 java 代码结构的顶层，该模块描述符明确地定义了我们的模块需要什么依赖关系，以及哪些模块被外部使用

设计目的

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

使用举例

  /**
  * requires:指明对其它模块的依赖
  */
  module java9demo { 
        requires java9test; 
        requires java.logging; 
        requires junit;
   }

  /**
  * exports:控制着哪些包可以被其它模块访问到。所有不被导出的包 默认都被封装在模块里面
  */
  module java9test {
        exports com.liuhuan.study; 
  }

jShell命令

设计目的

即写即得、快速运行

使用举例

调用命令

获取帮助

基本使用

导包

默认已经导入的包

使用外部编辑器编写代码

退出

接口中的私有方法

Java 8 中规定接口中的方法除了抽象方法之外，还可以定义静态方法和默认的方法。一定程度上，扩展了接口的功能，此时的接口更 像是一个抽象类。在 Java 9 中，接口更加的灵活和强大，连方法的访问权限修饰符都可以声明为 private 的了，此时方法将不会成为你对外暴露的 API 的一部分

使用举例

public interface MyInterface {

    void normalInterfaceMethod();

    default void methodDefault1() {
        init();
    }

    private void init() {
        System.out.println("默认方法中的通用操作");
    }

}

class MyInterfaceImpl implements MyInterface {

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

    public static void main(String[] args) {
        MyInterface impl = new MyInterfaceImpl(); 
        impl.methodDefault1();
    }
}

钻石操作符(Diamond Operator)使用升级

能够在匿名实现类中使用钻石操作符

使用举例

   private List<String> flattenStrings(List<String>... lists) {
        Set<String> set = new HashSet<>() {};
        for (List<String> list : lists) {
            set.addAll(list);
        }
        return new ArrayList<>(set);
    }

try语句关闭资源

使用举例

      InputStreamReader reader = new InputStreamReader(System.in); 
      OutputStreamWriter writer = new OutputStreamWriter(System.out); 
      //reader、writer使用之后会自动关闭
      try(reader;writer){
            //reader、writer 是 final 的，不可再被赋值
      }catch (IOException e){
            e.printStackTrace(); 
      }

String、StringBuffer、StringBuilder存储结构变更

String存储结构由char变更为byte，增加了一个字符编码的表识，对于存储非中文字符可以减少一半的存储空间

java8

/** The value is used for character storage. */
private final char value[];

java9

private final byte[] value;

集合工厂方法:快速创建只读集合

使用举例

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) 
);

Stream API增强

takeWhile()的使用:

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

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

dropWhile()的使用:

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

List<Integer> list = Arrays.asList(45,43,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); 
list.stream().dropWhile(x -> x < 5)
                  .forEach(System.out::println);

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

iterator()重载的使用

//原来的控制终止方式:
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);

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);