Java基础-Java 9&10&11新特性

1. Java 9新特性

• Java9提供了超过150项新功能特性，包括模块化系统、可交互的REPL工具：jshell、JDK编译工具，Java公共API和私有代码，以及安全增强、扩展提升、性能管理改善等
• JDK和JRE目录结构改变：JDK8: /bin /include /jre /lib;
• JDK9: /bin /conf /indlude /jmods /legal /lib

1.1 模块化系统

• Jigsaw项目->Modularity，Java运行越来越臃肿，每次启动JVM时，不管其中的类是否加载，都加载rt.jar，模块化可以根据模块的需要加载程序运行需要的class
• 用模块来管理package，通过声明某个package暴露模块的概念，在package外再裹一层，不声明默认就是隐藏

1.2 REPL工具-jshell命令

• 交互式编程环境REPL(read-evaluate-print-loop)，即写即得，快速运行

1.3 接口中的私有方法

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

public interface MyInterface {
    //下面三个方法的权限修饰符都是public
    void methodAbstract();
    static void methodStatic(){
        System.out.println("接口中的静态方法");
    }
    default void methodDefault(){
        System.out.println("接口中的默认方法");
    }
    //JDK9中允许接口中定义私有的方法
    private void methodPrivate(){
        System.out.println("私有方法");
    }
}

1.4 钻石操作符的使用升级

• 与匿名实现类共同使用钻石操作符(diamond operator)在Java8中会报错

@Test
    public void test2(){
        Comparator<Object> com = new Comparator<>() {
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }
        };
    }

1.5 try语句语法改变

• Java8中，可以实现资源的自动关闭，但要求执行后必须关闭的所有资源必须在try子句中初始化

//Java9中新特性try操作的升级
    @Test
    public void test3() {
        //Java8中资源关闭操作
        try (InputStreamReader reader = new InputStreamReader(System.in)) {

        } catch (IOException e) {
            e.printStackTrace();
        }

        //Java9中资源关闭操作
        InputStreamReader reader = new InputStreamReader(System.in);
        try (reader) {

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

1.6 String底层存储结构的变更

• String再也不用char[]来存储了，改成了byte[]加上编码标记，节约空间
• StringBuffer和StringBuilder也改变了

public class Java9Test1 {

    //新特性：集合工厂方法，创建只读集合。
    @Test
    public void test1() {
        //Java8的写法
        List<String> strings = new ArrayList<>();
        strings.add("Joe");
        strings.add("Bob");
        strings.add("Bill");

        //返回的是一个只读的集合
        strings = Collections.unmodifiableList(strings);

        //strings.add("Tom");

        System.out.println(strings);
    }

    @Test
    public void test2() {

        List<String> list = Collections.unmodifiableList(Arrays.asList("A", "B", "C"));
        Set<String> set = Collections.unmodifiableSet(new HashSet<>(Arrays.asList("a", "b", "c")));
        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));

        //Java9新特性
        List<Integer> list1 = List.of(1, 2, 3, 4, 5);
        //list1.add(6);
        System.out.println(list1);
        Set<Integer> set1 = Set.of(23, 452, 543, 136, 146, 677);
        //set1.add(346);
        System.out.println(set1);
        Map<String, Integer> map1 = Map.ofEntries(Map.entry("Tom", 23), Map.entry("Abb", 25));
        System.out.println(map1);
    }
    //Java9新特性：InputStream新方法transferTo()
    @Test
    public void test3() {
        ClassLoader classLoader = this.getClass().getClassLoader();
        try (InputStream is = classLoader.getResourceAsStream("hello.txt");
             OutputStream os = new FileOutputStream("src\\hello1.txt")) {
            is.transferTo(os);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

1.7 增强Stream API

• Java9中，Sream接口中添加了4个新方法：takeWhile,dropWhile,ofNullable,还有itereate方法的新重载方法，可以让你提供一个Predicate（判断条件）来指定什么时候结束迭代
• Optional和Stream之间的结合也得到了改进。可以通过Optional的新方法stream()将一个Optional对象转换为一个（可能是空的）Stream对象

public class Java9Test2 {
    //java9新特性：Stream API加强
    @Test
    public void test1() {
        List<Integer> list = Arrays.asList(12, 34, 63, 19, 2, 1, 85, 23);
        //返回从开头开始的按照指定规则尽可能多的元素
        //list.stream().takeWhile(x -> x < 60).forEach(System.out::println);

        //与takeWhile()相反，返回剩余的元素
        list.stream().dropWhile(x -> x < 60).forEach(System.out::println);
    }

    @Test
    public void test2() {
        //of()不能单一为null
        Stream<Integer> stream = Stream.of(null, null);
        stream.forEach(System.out::println);
        //ofNullble()形参变量可以为null值的单个元素
        Stream<Object> stream1 = Stream.ofNullable(null);
        System.out.println(stream1.count());
    }

    @Test
    public void test3() {
        Stream.iterate(0, x -> x + 1).limit(10).forEach(System.out::println);
        //java9重载方法
        Stream.iterate(0, x -> x < 100, x -> x + 1).forEach(System.out::println);
    }
}

1.8 Javascript引擎升级：Nashorn

• Nashorn在JDK9中得到改进，他为Java提供轻量级的JavaScript运行时。
• JDK9包含一个用来解析Nashorn的ECMAScript语法树的API

2. Java 10新特性

• JDK10新增12个JEP(JDK Enhancement Proposal特性加强建立)
• 最主要的是局部变量类型推断，var不是一个关键字

public class Java10Test {

    //局部变量的类型推断
    @Test
    public void test1() {
        //声明变量时，根据所附的值，推断变量的类型
        var num = 10;
        var list = new ArrayList<String>();
        list.add("123");

        for (var s : list) {
            System.out.println(s);
            System.out.println(s.getClass());
        }

    }

    @Test
    public void test2() {
        //var num ;
        //System.out.println(num.getClass());

        Supplier<Double> sup = () -> Math.random();
        //var sup1 = () -> Math.random();

        Consumer<String> con = System.out::println;
        //var con1 = System.out::println;

        int[] arr = {1, 2, 3, 4};
        //var arr = {1, 2, 3, 4};

    }

//    public var m1() {
//        return 0;
//    }

//    public void m2(var num){
//
//    }

    //java10新特性:copyOf()方法，用于创建一个只读的集合
    @Test
    public void test3() {
        var list1 = List.of("java", "python");
        var copy1 = List.copyOf(list1);
        System.out.println(list1 == copy1);//true

        var list2 = new ArrayList<String>();
        var copy2 = List.copyOf(list2);
        System.out.println(list2 == copy2);//false
        //copyOf(col)如果参数col是一个只读集合，则返回值即为col；如果不是只读集合，则返回一个新只读集合
    }

}

3. Java 11新特性

• JDK11增加了17个主要JEP，引入了两种新的GC，其中包括跨时代意义的ZGC
• 全新的HttpClient API，替换原有的HttpURLConnection
• 更简洁的编译运行程序 java XXXX.java
• 废弃Nashorn引擎，可以考虑使用GraalVM

public class Java11Test {
    //java11新特性：String中新增的方法
    @Test
    public void test1() {
        System.out.println("\t  \n".isBlank());
        System.out.println("---" + " \t abc \t \n" + "----".strip() + "-----");
        System.out.println("abc".repeat(5));
        System.out.println("ef\n g".lines().count());
    }

    //java11新特性：Optional新增方法
    @Test
    public void test2() {
        Optional<Object> op = Optional.empty();
        System.out.println(op.isPresent());//判断内部的value是否存在
        System.out.println(op.isEmpty());//判断内部的value是否为空
        op = Optional.of("abc");
        var obj = op.orElseThrow();
        System.out.println(obj);

        Optional<String> op1 = Optional.of("hello");
        Optional<Object> op2 = op.or(() -> op1);
        System.out.println(op2);
    }

    //java11新特性：局部变量类型推断升级
    @Test
    public void test3() {
        Consumer<String> con = (@Deprecated var t) -> System.out.println(t.toUpperCase());
    }
    
}

4. 当前JDK看不到什么？

• JSON API
• 新的货币API