Java 9 新特性

public class NewPointTest {
    /**
     * 1.语法改进:钻石操作符(Diamond Operator)使用升级 即 泛型 <>
     *  我们将能够与匿名实现类共同使用钻石操作符（diamond operator）
     */
    @Test
    public void test1(){
        Set<String> set = new HashSet<>();
        set.add("hello");
        set.add("hi");
        set.add("你好");
        Set<String> set2 = new HashSet<>(){};//可以跟{} 匿名内部类一起使用
    }
    /**
     * 2.语法改进 : try语句
     */
    //在java 8 之前，我们习惯于这样处理资源的关闭
    @Test
    public void test2(){
        InputStreamReader reader = null;
        try{
            reader = new InputStreamReader(System.in);
            reader.read();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if (reader != null) {
                try{
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    //java 8 中，可以实现资源的自动关闭，但是要求执行后必须关闭的所有资源必须在 try 子句中初始化，否则编译不通过。
    @Test
    public void test3(){
        try(InputStreamReader reader = new InputStreamReader(System.in)){
        }catch (IOException e){
            e.printStackTrace();
        }
    }
    //java 9 中，用资源语句编写 try 将更容易，我们可以在 try 子句中使用已经初始化过的资源，此时的资源是 final 的
    @Test
    public void test4(){
        InputStreamReader reader = new InputStreamReader(System.in);
        OutputStreamWriter writer = new OutputStreamWriter(System.out);
        try(reader;writer){
            //reader = null; //reader 是 final 的，不可再被赋值
        }catch (IOException e){
            e.printStackTrace();
        }
    }
    /**
     * String 存储结构变更
     * String 再也不用 char[] 来存储啦，改成了 byte[] 加上编码标记，节约了一些空间。
     */
    @Test
    public void test5(){
        /**
         * String : 在jdk 8及以前，底层使用 char[] 存储,jdk 9 :底层使用 byte[] (encoding flag)
         * StringBuffer : 在jdk 8及以前，底层使用 char[] 存储,jdk 9 :底层使用 byte[] (encoding flag)
         * StringBuilder : 在jdk 8及以前，底层使用 char[] 存储,jdk 9 :底层使用 byte[] (encoding flag)
         *
         * String: 不可变的字符序列
         * StringBuffer: 可变的字符序列，线程安全的，效率低
         * StringBuilder: 可变的字符序列，线程不安全，效率高(jdk 5.0)
         */
        String str = "hello";
        StringBuffer sbf = new StringBuffer("hello");
        StringBuilder sbd = new StringBuilder("hello");
    }
    /**
     * java 9 集合工厂方法：快速创建只读集合
     *
     */
    //java 9 之前 ，创建一个只读特点的集合
    //缺点：我们一下写了五行。即：它不能表达为单个表达式。
    @Test
    public void test6(){
        //List
        List<String> namesList = new ArrayList<>();
        namesList.add("Joe");
        namesList.add("Bob");
        namesList.add("Bill");
        namesList = Collections.unmodifiableList(namesList);
//        namesList.add("hi"); //UnsupportedOperationException
        System.out.println(namesList);
        //Set
        Set<String> set = Collections.unmodifiableSet(new HashSet<>(Arrays.asList("a", "b", "c")));

        //Map
        //如下操作不适用于 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));
    }
    /**
     * Java 9 因此引入了方便的方法，这使得类似的事情更容易表达。
     * 调用集合中静态方法 of()，可以将不同数量的参数传输到此工厂方法,中。此功能可用于 Set 和 List，也可用于 Map 的类似形式。
     * 此时得到的集合，是不可变的：在创建后，继续添加元素到这些集合会导致“UnsupportedOperationException”
     */
    @Test
    public void test7(){
        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
     * 在 Java 9 中，Stream API 变得更好，Stream 接口中添加了 4 个新的方法：
     * dropWhile, takeWhile, ofNullable，
     * 还有个 iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代。
     */
    @Test
    public void test8(){
        //1.takeWhile
        //用于从 Stream 中获取一部分数据，接收一个 Predicate 来进行选择。在有序的Stream 中，takeWhile 返回从开头开始的尽量多的元素。
        //注意区分filter，filter是对所有元素进行过滤，而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);//45 43

        System.out.println("-------------------");

        list = Arrays.asList(1,2,3,4,5,6,7,8);
        list.stream().takeWhile(x -> x < 5).forEach(System.out::println);//1 2 3 4

        //2.dropWhile:dropWhile 的行为与 takeWhile 相反，返回剩余的元素。
        List<Integer> list2 = Arrays.asList(45,43,76,87,42,77,90,73,67,88);
        list2.stream().dropWhile(x -> x < 50).forEach(System.out::println);//76 87 42 77 90 73 67 88


        System.out.println("------------------");

        list2 = Arrays.asList(1,2,3,4,5,6,7,8);
        list2.stream().dropWhile(x -> x < 5).forEach(System.out::println);//5 6 7 8
        System.out.println("---------------");

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

//        Stream<Object> stream1 = Stream.of(null);
        //System.out.println(stream1.count());// NullPointerException 不能完全为 null

        Stream<String> stringStream = Stream.of("AA", "BB", null);
        System.out.println(stringStream.count());//3  元素不全为null，可以使用

        //ofNullable()：允许值为 null，即允许元素全为null
        Stream<Object> stream2 = Stream.ofNullable(null);
        System.out.println(stream2.count());//0

        Stream<String> stream = Stream.ofNullable("hello world");
        System.out.println(stream.count());//1

        System.out.println("-----------------");
        //4.iterator()重载的使用
//        原来的控制终止方式：
        Stream.iterate(1,i -> i + 1).limit(10)
                .forEach(System.out::println);// 1 2 3 4 5 6 7 8 9 10
        System.out.println("====================");
//        现在的终止方式：
        Stream.iterate(1,i -> i < 10,i -> i + 1)
                .forEach(System.out::println);//1 2 3 4 5 6 7 8 9
    }
    /**
     * Optional 类中 stream()的使用
     * 创建stream的方法：①通过集合的stream() ②通过数组工具类：Arrays ③Stream中的静态方法:of()④iterator()/generate()
     * 现在又加了一种：Optional.stream()
     */
    @Test
    public void test9(){
        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); //Tom Jerry Tim
    }
    /**
     *全新的 HTTP 客户端 API
     * HTTP，用于传输网页的协议，早在 1997 年就被采用在目前的 1.1版本中。直到 2015 年，HTTP2 才成为标准。
     * HTTP/1.1和HTTP/2的主要区别是如何在客户端和服务器之间构建和传输数据。HTTP/1.1 依赖于请求/响应周期。 HTTP/2 允许服务器
     * “push”数据：它可以发送比客户端请求更多的数据。 这使得它可以优先处理并发送对于首先加载网页至关重要的数据。
     * Java 9 中有新的方式来处理 HTTP 调用。它提供了一个新的 HTTP客户端（ HttpClient ）， 它 将 替代仅适用于 blocking 模式的
     * HttpURLConnection （HttpURLConnection是在HTTP 1.0的时代创建的，并使用了协议无关的方法），并提供对 WebSocket 和 HTTP/2 的支持。
     * 此外，HTTP 客户端还提供 API 来处理 HTTP/2 的特性，比如流和服务器推送等功能。
     * 全新的 HTTP 客户端 API 可以从 jdk.incubator.httpclient 模块中获取。
     */
    @Test
    public void test10(){


    }
}