JAVA9 新特性完整使用

最新推荐文章于 2024-05-28 23:41:13 发布

小坏讲微服务

最新推荐文章于 2024-05-28 23:41:13 发布

阅读量960

点赞数

分类专栏：小坏讲java基础小坏讲后端文章标签： java

本文链接：https://blog.csdn.net/qq_42082701/article/details/117809323

版权

小坏讲java基础同时被 2 个专栏收录

28 篇文章 3 订阅

订阅专栏

小坏讲后端

28 篇文章 4 订阅

订阅专栏

JAVA9 新特性完整使用

一、介绍（java9新特性）
二、接口中声明私有方法（java9新特性）
三、语法改进（java9新特性）

一、介绍（java9新特性）

1、Oracle JDK9 Documentation（java9新特性）

JDK9 Documentation

2、官方提供新特性列表（java9新特性）

供新特性列表

3、JDK和JRE 目录改变（java9新特性）

在这里插入图片描述

4、模块化系统：Jigsaw -> Modularity（java9新特性）

在这里插入图片描述

5、java REPL工具 jshell（java9新特性）

快速测试main方法、不用在编译、执行了
在这里插入图片描述

edit调出编译框手写也可以的、详细操作自己查看网上的列子测试哦

在这里插入图片描述

二、接口中声明私有方法（java9新特性）

语法改进 ：
java8中 规定接口的方法除了抽象方法之外，还可以定义静态方法和默认方法、一定程度上，扩展了接口的功能，此时的接口更像是一个抽象类

java9 接口更加的灵活和强大，连方法的访问权限修饰符都可以声明为private的了、此时方法将不会成为你对外暴漏的API的一部分

为了方便测试我设置了jdk8 演示了一个私有方法在接口、它提示了 private not、然后我有切换到了java9 就没问题了

public interface MyInterface {

    //如下的三个方法的权限修饰符都是public 归属jdk 8
    void methodAbstract();

    static void methodStatic(){
        System.out.println("我是接口中的静态方法");
    }

    default void methodDefault(){
        System.out.println("我是接口中的默认方法");

        methodPrivate();
    }

    //jdk 9中允许接口中定义私有的方法
    private void methodPrivate(){
        System.out.println("我是接口中的私有方法");
    }
}

编写实现类进行测试调用

public class MyInterfaceImpl implements MyInterface {


    @Override
    public void methodAbstract() {

    }

//    @Override
    public void methodDefault() {
        System.out.println("实现类重写了接口中的默认方法");
    }

    public static void main(String[] args) {
        //接口中的静态方法只能由接口自己调用
        MyInterface.methodStatic();
        //接口的实现类不能调用接口的静态方法
//        MyInterfaceImpl.methodStatic();

        MyInterfaceImpl impl = new MyInterfaceImpl();
        impl.methodDefault();
        //接口的私有方法，不能在接口外部调用
//        impl.methodPrivate();
    }
}

三、语法改进（java9新特性）

1、钻石操作符使用升级（java9特性）（java9新特性）

java9 特性：钻石操作符的升级

钻石操作符与匿名内部类在java 8中不能共存。在java9可以。
此处换成java8就报错、换成java9正常、很小的一个特性


    @Test
    public void test2() {
        //钻石操作符与匿名内部类在java 8中不能共存。在java9可以。
        Comparator<Object> com = new Comparator<>() {
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }
        };

        //jdk7中的新特性：类型推断
        ArrayList<String> list = new ArrayList<>();

    }

2、try操作的升级（java9特性）

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

资源关闭非常方便不需要再写 final来close、直接丢到try里自动帮你关闭

 //java9 特性六：try操作的升级
    public static void main(String[] args) {
        //java 8之前的资源关闭的操作
//        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 {
//            if(reader != null){
//                try {
//                    reader.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//
//            }
//        }

        //java 8中资源关闭操作: Java 8 中，可以实现资源的自动关闭
        //要求自动关闭的资源的实例化必须放在try的一对小括号中
//        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();
//        }

        //java9中资源关闭操作：需要自动关闭的资源的实例化可以放在try的一对小括号外。
        //此时的资源属性是常量，声明为final的，不可修改
        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);
            }

//            reader = null;
        } catch (IOException e) {
            e.printStackTrace();
        }


    }

3、String 结构的存储变更（java9特性）

@Stable
private final byte[] value;

4、快速创建只读集合(java9特性)

集合工厂方法：快速创建只读集合
要创建一个只读、不可改变的集合，必须构造和分配它，然后添加元素，最后包装成-个不可修改的集合。

1、创建只读集合(java8)

创建只读集合(java8)

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

    }

创建只读集合(java8)

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

    }

2、创建只读集合(java9)

集合.of 来创建只读集合

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


    }

5、InputStream中的transferTo方法(java9特性)

InputStream终于有了一个非常有用的方法: transferTo，可以用来将数据直接传输到OutputStream，这是在处理原始数据流时非常常见的一种用法，如下

    @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();
        }
    }

6、增强的Stream API（java9特性）

1、前言（java9新特性）

1、Java 的Steam API是java标准库最好的改进之一，让开发者能够快速运算，
从而能够有效的利用数据并行计算。Java 8提供的Steam能够利用多核架构
实现声明式的数据处理。

2、在Java9中，Stream API变得更好，Stream接口中添加了4个新的方法:
takeWhile, dropWhile, ofNullable，还有个iterate 方法的新重载方法，可以
让你提供一个Predicate(判断条件)来指定什么时候结束迭代。

3、除了对Stream本身的扩展，Optional和Stream之间的结合也得到了改进。
现在可以通过Optional的新方法stream()将–个Optional对象转换为一个
(可能是空的)Stream对象。

2、takeWhile （返回从开头开始的按照指定规则尽量多的元素）（java9新特性）

意思就是从60开始前面的元素输出

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

    }

3、dropWhile （与 takeWhile 相反，返回剩余的元素。）（java9新特性）

意思就是从60开始后面的元素输出

    @Test
    public void test2(){
        List<Integer> list = Arrays.asList(23, 43, 45, 55, 61, 54, 32, 2, 45, 89, 7);
        //dropWhile():与 takeWhile 相反，返回剩余的元素。
        list.stream().dropWhile(x -> x < 60).forEach(System.out::println);
    }

7、ofNullable()：形参变量是可以为null值的单个元素（java9新特性）

    @Test
    public void test2(){
        //of()参数中的多个元素，可以包含null值
        Stream<Integer> stream1 = Stream.of(1, 2, 3,null);
        stream1.forEach(System.out::println);
        //of()参数不能存储单个null值。否则，报异常
//        Stream<Object> stream2 = Stream.of(null);
//        stream2.forEach(System.out::println);
        Integer i = 10;
        i = null;
        //ofNullable()：形参变量是可以为null值的单个元素
        Stream<Integer> stream3 = Stream.ofNullable(i);
        long count = stream3.count();
        System.out.println(count);
    }

7、iterate()：java9中新增的重载的方法（java9新特性）

   @Test
    public void test3(){
		//java8中
        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);
    }

8、Optional提供了新的方法stream() （java9新特性）

java9新特性十一：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);
        stream.flatMap(x -> x.stream()).forEach(System.out::println);

    }

9、javaScript引擎升级：Nashorn（java9新特性）

在这里插入图片描述

小坏讲微服务

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
JAVA9 新特性完整使用

这里写目录标题介绍1、Oracle JDK9 Documentation2、官方提供新特性列表3、JDK和JRE 目录改变4、模块化系统：Jigsaw -> Modularity二级目录三级目录介绍1、Oracle JDK9 DocumentationJDK9 Documentation2、官方提供新特性列表供新特性列表3、JDK和JRE 目录改变4、模块化系统：Jigsaw -> Modularity二级目录三级目录...
复制链接

扫一扫