阶段十-java新特性

JDK9新特性

1.模块化系统

? ? ? jar包结构的变化

? ? ? ? jar -》model -》package -》class

? ? ? 通过不同的模块进行开发

? ? ? 每个模块都有自己的模块配置文件module-info.java

2.JShell

? ? ? ? JDK9自带的命令行开发，在进行简单的代码调试时可以直接编译使用

? ? ? ? 可以定义变量，方法，和java中的一样

? ? ? ? /list 所有的代码片段 /vars 所有的变量? /methods 所有的方法

?

3.接口私有方法

? ? ? ?

4.钻石操作符使用升级

在jdk8中，如下代码是报错的

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

<>必须写类型。

而在jdk9中，上述代码就不报错，这是对<>钻石运算符的一个升级。

5.try语句升级

6.String存储结构变更

String底层的char[]字符数组发生改变，变成了byte[]字节数组

StringBuffer和StringBuilder也变成了byte[]字节数组

ISO-8859-1/Latin-1(每个字节一个字节)的字符字符)或UTF-16(每个字符两个字节)，具体取决于内容字符串的。编码标志将指示使用哪种编码。

7.集合特性of

public class Demo {
    public static void main(String[] args) {
        //对于不可变集合的增强
        //JDK8创建一个不可变集合
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("张三");
        list.add("张三");
        //集合工具类
        Collection<String> results = Collections.unmodifiableCollection(list);
        System.out.println(results);
        //报错
        /*results.add("李四");
        System.out.println(results);*/

        //JDK9中创建自读集合
        List<String> list2 = List.of("张三", "张三", "张三");
        //报错
        /*list2.set(0,"李四");*/
        System.out.println(list2);
        Set<String> set1 = Set.of("AA", "BB", "CC");
        System.out.println(set1);
        Map<String, String> map = Map.of("k1", "v1", "k2", "v2");
        System.out.println(map);

    }
}

8.InputStream增强

public class Demo {
    public static void main(String[] args) throws Exception{
        //直接通过一个方法将输入流传递到输出流
        FileInputStream fileInputStream = new FileInputStream("D:\\a.txt");
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\b.txt");

        try(fileOutputStream;fileInputStream) {
            fileInputStream.transferTo(fileOutputStream);
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

9.增强的Stream API

public class Demo {
    public static void main(String[] args) {
        //从开头开始，到第一个不满足条件的结束
        List<Integer> list = Arrays.asList(10,20,30,40,30,20,10);
        list.stream().takeWhile(t->t<40).forEach(System.out::println);

        //和takeWhile相反，从头开始第一个不满足开始后面的
        List<Integer> list2 = Arrays.asList(5,20,30,50,60,20,10);
        list2.stream().dropWhile(t->t<40).forEach(System.out::println);

        //允许通过
        Stream<String> streams = Stream.of("AA","BB",null);
        System.out.println(streams.count());
        //不允许通过
        Stream<Object> stream1 = Stream.of(null);
        System.out.println(stream1.count());
        //允许通过,ofNullable中可以为一个null
        Stream<Object> stream2 = Stream.ofNullable(null);
        System.out.println(stream2.count());

        //iterate
        //可以提供条件结束迭代
        //原本的方式
        Stream.iterate(1,integer -> integer + 1).limit(50).forEach(System.out::println);
        //增强的方式
        //条件写在括号里面
        Stream.iterate(1,i -> i<60,i -> i + 1).forEach(System.out::println);
    }
}

10.Optional 类中stream()使用

public class Demo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        Optional<List<String>> optional = Optional.ofNullable(list);
        optional.stream().forEach(System.out::println);
        //flatMap可以便利Optional中的每一个元素
        optional.stream().flatMap(x->x.stream()).forEach(System.out::println);
    }
}

JDK10新特性

1.局部变量类型推断

java是强语言类型，前面是什么类型，后面就是什么类型，这个var能推断出后面是什么类型

js是弱语言类型，什么类型都行

public class Demo {
    public static void main(String[] args) {
        //局部类型推断
        var i = 1;
        var list = new ArrayList<String>();
        //不能推断的情况
        //初始值为null
        var a = null;
        //方法引用
        var r = System.out::println;
        //Lambda表达式
        var c = (Integer b) -> {
            return b+"";
        };
        var d = {2,3,4};
    }
}

var 不是一个关键字：你不需要担心变量名或方法名会与 var发生冲突

2.新增不可变集合方法（只读）

public class Demo1 {
    public static void main(String[] args) {
        //只读集合增强
        //将不是只读集合的集合变成只读集合
        //copyOf
        //示例1
        var list1 = List.of("AA","BB","CC");
        var list2 = List.copyOf(list1);
        System.out.println(list1==list2);//true

        //示例2
        var list3 = new ArrayList<String>();
        list3.add("AA");
        list3.add("BB");
        List<String> list4 = List.copyOf(list3);
        System.out.println(list3==list4); //false
    }
}

JDK11新特性

1.垃圾回收器ZGC

2.Optional加强

isEmpty()判断是否为空

3.新增HTTP客户端API

public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request =
        HttpRequest.newBuilder(URI.create("http://www.baidu.com")).build();
    HttpResponse.BodyHandler<String> responseBodyHandler = HttpResponse.BodyHandlers.ofString();
    HttpResponse<String> response = client.send(request, responseBodyHandler);
    String body = response.body();
    System.out.println(body);
}

JDK 14 新特性

空指针异常更加具体

JDK 16 新特性

switch增强

public class Demo {
    public static void main(String[] args) {
        int level = new Random().nextInt(12);
        String jiJi = null;
        switch (level){
            case 3,4,5 -> jiJi =  "春天";
            case 6,7,8 -> jiJi =  "夏天";
            case 9,10,11 -> jiJi =  "秋天";
            case 12,1,2 -> jiJi = "冬天";
        };
        System.out.println(jiJi);
    }
}