JAVA9 新特性完整使用

╰半橙微兮° 2022-10-06 04:55 141阅读 0赞

### JAVA9 新特性 完整使用 ###

*  一、介绍（java9新特性）
 *   *  1、Oracle JDK9 Documentation（java9新特性）
     *  2、官方提供新特性列表（java9新特性）
     *  3、JDK和JRE 目录改变（java9新特性）
     *  4、模块化系统：Jigsaw -> Modularity（java9新特性）
     *  5、java REPL工具 jshell（java9新特性）
 *  二、接口中声明私有方法（java9新特性）
 *  三、语法改进（java9新特性）
 *   *  1、钻石操作符使用升级（java9特性）（java9新特性）
     *  2、try操作的升级（java9特性）
     *  3、String 结构的存储变更（java9特性）
     *  4、快速创建只读集合(java9特性)
     *   *  1、创建只读集合(java8)
         *  2、创建只读集合(java9)
     *  5、InputStream中的transferTo方法(java9特性)
     *  6、增强的Stream API（java9特性）
     *   *  1、前言（java9新特性）
         *  2、takeWhile （返回从开头开始的按照指定规则尽量多的元素）（java9新特性）
         *  3、dropWhile （与 takeWhile 相反，返回剩余的元素。）（java9新特性）
     *  7、ofNullable()：形参变量是可以为null值的单个元素（java9新特性）
     *  7、iterate()：java9中新增的重载的方法（java9新特性）
     *  8、Optional提供了新的方法stream() （java9新特性）
     *  9、javaScript引擎升级：Nashorn（java9新特性）

# 一、介绍（java9新特性） #

## 1、Oracle JDK9 Documentation（java9新特性） ##

[JDK9 Documentation][]

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

[供新特性列表][Link 1]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 1]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 2]

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

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 3]

# 二、接口中声明私有方法（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新特性） ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 4]

[JDK9 Documentation]: https://docs.oracle.com/javase/9/
[Link 1]: http://openjdk.java.net/projects/jdk9/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70]: /images/20221005/a5a8deae74d2478c8496fff501875271.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 1]: /images/20221005/320e5b919e3344b88c1337ae84e7f169.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 2]: /images/20221005/8878cbe4ce20411bbb6553304fdaa55e.png
[20210611113645837.png]: /images/20221005/acce47e8240d49838d94d49bd56434ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 3]: /images/20221005/4621871b99954f028a72f69121c085cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 4]: /images/20221005/c8f471288bbd42ec9786825952c7ff0d.png