Java-day30（Java9&Java10& Java11新特性）

Java 9 的新特性

Java 9 中有哪些不得不说的新特性？

二、JDK 和 JRE 目录结构的改变

JDK 8 的目录结构

JDK 9 的目录结构

三、模块化系统: Jigsaw → Modularity

四、Java的REPL工具： jShell命令

调出jShell

获取帮助

基本使用

五、语法改进：接口的私有方法

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();//不能调用
	}
}

语法改进:钻石操作符使用升级

我们将能够与匿名实现类共同使用钻石操作符（diamond operator）在Java 8
中如下的操作是会报错的，Java 9中如下操作可以正常执行通过：

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

编译报错信息：Cannot use “<>” with anonymous inner classes

六、语法改进：try语句

java8之前：

public static void main(String[] args) {
        InputStreamReader reader = null;
        try {
            reader = new InputStreamReader(System.in);
            char[] cbuf = new char[20];
            int len;
            if ((len = reader.read(cbuf)) != -1) {
                String str = new String(cbuf, 0, len);
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (reader != null)
                    reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

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

public static void main(String[] args) {
 	try (InputStreamReader reader = new InputStreamReader(System.in)) {
            char[] cbuf = new char[20];
            int len;
            if ((len = reader.read(cbuf)) != -1) {
                String str = new String(cbuf, 0, len);
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
     }
}

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

public static void main(String[] args) {
 	InputStreamReader reader = new InputStreamReader(System.in);
        try(reader) {
            char[] cbuf = new char[20];
            int len;
            if ((len = reader.read(cbuf)) != -1) {
                String str = new String(cbuf, 0, len);
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
     }
}

七、String存储结构变更

八、集合工厂方法：快速创建只读集合

    //java8中的写法：
    @Test
    public void test1() {
        List<String> namesList = new ArrayList<>();
        namesList.add("Joe");
        namesList.add("Bob");
        namesList.add("Bill");
        //返回的namesList是一个只读的集合
        namesList = Collections.unmodifiableList(namesList);
        namesList.add("Tom");

        System.out.println(namesList);

    }

    @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")));
        // 如下操作不适用于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));

    }

    @Test
    public void test3() {
        //此时得到的集合list也是一个只读集合。
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        //报异常
        list.add(6);

    }

    //java9新特性八：集合工厂方法：创建只读集合
    @Test
    public void test4() {
        List<Integer> list1 = List.of(1, 2, 3, 4, 5);
        //不能添加
//        list1.add(6);
        System.out.println(list1);

        Set<Integer> set1 = Set.of(23, 3, 54, 65, 43, 76, 87, 34, 46);
        //不能添加
//        set1.add(4);
        System.out.println(set1);

        Map<String, Integer> map1 = Map.of("Tom", 23, "Jerry", 54, "HanMeimei", 12);
        //不能添加
        //map1.put("Lilei",34);

        System.out.println(map1);

        Map<String, Integer> map2 = Map.ofEntries(Map.entry("Tom", 34), Map.entry("Jerry", 21));
//        map2.put("Lilei",34);
        System.out.println(map2);


    }

九、InputStream 加强

//java9新特性九：InputStream的新方法:tranferTo()
    @Test
    public void test5() {
        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();
        }
    }

十、增强的 Stream API

takeWhile() 与dropWhile()

    @Test
    public void test1(){
        List<Integer> list = Arrays.asList(23, 43, 45, 55, 61, 54, 32, 2, 45, 89, 7);
        //takeWhile 返回从开头开始的按照指定规则尽量多的元素
//        list.stream().takeWhile(x -> x < 60).forEach(System.out::println);//23 43 45 55
        //dropWhile():与 takeWhile 相反，返回剩余的元素。
        list.stream().dropWhile(x -> x < 60).forEach(System.out::println);//61 54 32 2 45 89 7
    }

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

@Test
    public void test2(){
        //of()参数中的多个元素，可以包含null值
        Stream<Integer> stream1 = Stream.of(1, 2, 3,null);
        stream1.forEach(System.out::println);//1 2 3 null
       
		//of()参数不能存储单个null值。否则，报异常
//        Stream<Object> stream2 = Stream.of(null);
//        stream2.forEach(System.out::println);
		//这种被允许
		//Stream<Object> stream2 = Stream.of(null,null);

        Integer i = 10;
        i = null;
        //ofNullable()：形参变量是可以为null值的单个元素
        Stream<Integer> stream3 = Stream.ofNullable(i);
        long count = stream3.count();
        System.out.println(count);//0
    }

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

 @Test
    public void test3(){

        Stream.iterate(0,x -> x + 1).limit(10).forEach(System.out::println);


        //java9中新增的重载的方法：可以加具体非限制条件这里是小于100
        Stream.iterate(0,x -> x < 100,x -> x + 1).forEach(System.out::println);
    }

十一、Optional获取Stream的方法

Optional类中stream()的使用

    @Test
    public void test4(){
        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();
//        long count = stream.count();
//        System.out.println(count);//1 list作为一个元素
        stream.flatMap(x -> x.stream()).forEach(System.out::println);

    }

十二、Javascript引擎升级：Nashorn

Java 10 新特性

局部变量类型推断

/*
    java10新特性一：局部变量的类型推断

     */
    @Test
    public void test1() {
        //1.声明变量时，根据所附的值，推断变量的类型
        var num = 10;

        var list = new ArrayList<Integer>();
        list.add(123);

        //2.遍历操作
        for (var i : list) {
            System.out.println(i);
            System.out.println(i.getClass());
        }

        //3.普通的遍历操作
        for (var i = 0; i < 100; i++) {
            System.out.println(i);
        }

    }

    @Test
    public void test2() {
        //1.局部变量不赋值，就不能实现类型推断
//        var num ;

        //2.lambda表示式中，左边的函数式接口不能声明为var
//        Supplier<Double> sup = () -> Math.random();

//        var sup = () -> Math.random();

        //3.方法引用中，左边的函数式接口不能声明为var
//        Consumer<String> con = System.out::println;

//        var con = System.out::println;

        //4.数组的静态初始化中，注意如下的情况也不可以
        int[] arr = {1, 2, 3, 4};
//        var arr = {1,2,3,4};
    }

    @Test
    public void test3() {
//        情况1：没有初始化的局部变量声明
//        var s = null;


//        情况6：catch块
//        try{
//
//        }catch(var e){
//            e.printStackTrace();
//        }


    }
    //情况2：方法的返回类型
//    public var method1(){
//
        return 0;
//    }
    // 情况3：方法的参数类型
//    public void method2(var num){
//
//    }

    //情况4：构造器的参数类型
//    public Java10Test(var i){
//
//    }

    //情况5：属性
//    var num;


    @Test
    public void test4() {
        try {
            var url = new URL("http://www.atguigu.com");
            var connection = url.openConnection();
            var reader = new BufferedReader(
                    new InputStreamReader(connection.getInputStream()));
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

集合新增创建不可变集合的方法

//java10的新特性二：集合中新增的copyOf()，用于创建一个只读的集合
    @Test
    public void test5(){
        //示例1：
        var list1 = List.of("Java", "Python", "C");
        var copy1 = List.copyOf(list1);
        System.out.println(list1 == copy1); // true

        //示例2：
        var list2 = new ArrayList<String>();
        list2.add("aaa");
        var copy2 = List.copyOf(list2);
        System.out.println(list2 == copy2); // false
        

示例1和2代码基本一致，为什么一个为true,一个为false?
结论：copyOf(Xxx coll):如果参数coll本身就是一个只读集合，则copyOf()返回值即为当前的coll
如果参数coll不是一个只读集合，则copyOf()返回一个新的集合，这个集合是只读的。

源码：

    // make a copy, short-circuiting based on implementation class
    @SuppressWarnings("unchecked")
    static <E> List<E> listCopy(Collection<? extends E> coll) {
        if (coll instanceof AbstractImmutableList && coll.getClass() != SubList.class) {
            return (List<E>)coll;
        } else {
            return (List<E>)List.of(coll.toArray());
        }
    }

Java 11 新特性

一、新增了一系列字符串处理方法

    //java 11新特性一：String中新增的方法
    @Test
    public void test1(){
//        isBlank():判断字符串是否为空白
        System.out.println("  \t  \t  \n  ".isBlank());
//        strip():去除首尾空白
        System.out.println("-----" + "  \t abc \t  \n  ".strip() + "-------");
        System.out.println("-----" + "  \t abc \t  \n  ".trim() + "-------");
//        stripTrailing():去除尾部空格
        System.out.println("-----" + "  \t abc \t  \n  ".stripTrailing() + "-------");
//        stripLeading():去除首部空格
        System.out.println("-----" + "  \t abc \t  \n  ".stripLeading() + "-------");
//        repeat(int count):复制字符串
        String str1 = "abc";
        String str2 = str1.repeat(5);
        System.out.println(str2);

//        lines().count():行数统计
        String str3 = "abc\ndef\ng";
        System.out.println(str3.lines().count());
    }

二、Optional 加强

 //java11新特性二：Optional新增的方法
    @Test
    public void test6(){
        var op = Optional.empty();
        System.out.println(op.isPresent());//false  //判断内部的value是否存在
        System.out.println(op.isEmpty());//true   //判断内部的value是否存在

        op = Optional.of("abc");
        //orElseThrow():value非空，返回value；否则抛异常NoSuchElmentException
        var obj = op.orElseThrow();
        System.out.println(obj);//abc


        Optional<String> op1 = Optional.of("hello");
        //or:value非空,返回对应的Optional；value为空，返回形参封装的Optional
        //这里op调用or 如果op的value不为空 就直接返回op，为空就返回op1
        Optional<Object> op2 = op.or(() -> op1);
        System.out.println(op2);//Optional[abc]

    }

跟jdk8中orElse的区别：
这里返回的是容器，而orElse返回的是value.

三、局部变量类型推断升级

在var上添加注解的语法格式，在jdk10中是不能实现的。在JDK11中加入了这样的语法。

//错误的形式: 必须要有类型, 可以加上var
//Consumer<String> con1 = (@Deprecated t) -> System.out.println(t.toUpperCase());
//正确的形式:
//使用var的好处是在使用lambda表达式时给参数加上注解。
Consumer<String> con2 = (@Deprecated var t) -> System.out.println(t.toUpperCase());

四、全新的HTTP 客户端API

五、更简化的编译运行程序

六、废弃Nashorn引擎

废除Nashorn javascript引擎，在后续版本准备移除掉，有需要的
可以考虑使用GraalVM

七、ZGC

八、其它新特性