Java 9 新特性 工厂方法，stream,Optional，匿名内部类优化，接口的私有方法

Java 9 新特性 工厂方法，stream,Optional，匿名内部类优化

工厂方法

1. List.of() 方法
2. Set.of() 方法
3. Map.of() 方法
4. 这些集合造出来不可以修改

代码

    @Test
    public void t1() {
        //集合类新增工厂方法
//        这些集合造出来不可以修改
        Map<String, String> m1 = Map.of("a", "b", "c", "d");
        Set<String> s1 = Set.of("a", "b", "c", "d");
        List<String> l1 = List.of("a", "b", "c", "d");
        System.out.println(m1);//{a=b, c=d}
        System.out.println(s1);//[a, b, c, d]
        System.out.println(l1);//[a, b, c, d]
//        这样会报错
//        m1.clear();//UnsupportedOperationException
//        s1.clear();//UnsupportedOperationException
//        l1.clear();//UnsupportedOperationException
    }

新的stream

加了一些新的写法

 @Test
    public void t2() {
//        Stream
//                .of(null)   //如果传入null会报错
//                .forEach(System.out::println);

        Stream
                .ofNullable(null) //使用新增的ofNullable方法，这样就不会了，不过这样的话流里面就没东西了
                .forEach(System.out::println);

    }

    @Test
    public void t3() {
        Stream
                .iterate(0, i -> i + 1)
                //Java8只能像这样生成无限的流，第一个参数是种子，
                // 就是后面的UnaryOperator的参数i一开始的值，最后会返回一个值作为i的新值，
                // 每一轮都会执行UnaryOperator并生成一个新值到流中，这个是源源不断的，
                // 如果不加limit()进行限制的话，将无限生成下去。
                .limit(20)   //这里限制生成20个
                .forEach(System.out::println);

//        java9新增的方法
            Stream
                    //不知道怎么写？参考一下：for (int i = 0;i < 20;i++)
                    .iterate(0, i -> i < 20, i -> i + 1)  //快速生成一组0~19的int数据，中间可以添加一个断言，表示什么时候结束生成
                    .forEach(System.out::println);
    }
//    对数组的截断方法
    @Test
    public void t4(){
        Stream
                .iterate(0, i -> i + 1)
                .limit(20)
                .takeWhile(i -> i < 10)   //当i小于10时正常通过，一旦大于等于10直接截断
                .forEach(System.out::println);

        Stream
                .iterate(0, i -> i + 1)
                .limit(20)
                .dropWhile(i -> i < 10)   //和上面相反，上来就是截断状态，只有当满足条件时再开始通过
                .forEach(System.out::println);
    }

对Optional的增强

//    java9对ofNullable的改进 ifPresentOrElse
@Test
public void t5(){
        String str = null;
        Optional.ofNullable(str).ifPresentOrElse(s -> {  //通过使用ifPresentOrElse，我们同时处理两种情况
        System.out.println("被包装的元素为："+s);     //第一种情况和ifPresent是一样的
        }, () -> {
        System.out.println("被包装的元素为null");   //第二种情况是如果为null的情况
        });

        }
//    or 对optional的优化
@Test
public void t6(){
        String str = null;
        Optional.ofNullable(str)
        .or(() -> Optional.of("AAA"))   //如果当前被包装的类不是null，依然返回自己，但是如果是null，那就返回Supplier提供的另一个Optional包装
//                AAA只是举例 也可以是其他的类型
        .ifPresent(System.out::println);
        }

匿名内部类优化

现在可以直接匿名内部类省略泛型了

//    在Java 8及之前，匿名内部类是没办法使用钻石运算符进行自动类型推断的：
    @Test
    public void t7(){
        Test2<String> test = new Test2<>("AAA") {   //在低版本这样写是会直接报错的，因为匿名内部类不支持自动类型推断，但是很明显我们这里给的参数是String类型的，所以明明有机会进行类型推断，却还是要我们自己填类型，就很蠢
            //在Java 9之后，这样的写法终于可以编译通过了
            @Override
            public String test2() {
                return t;
            }
        };
    }

abstract class Test2<T>{   //这里我们写一个泛型类
    public T t;
    public Test2(T t) {
        this.t = t;
    }
    public abstract T test2();
}

接口

的私有方法
这个私有方法是给接口自己使用的不向外部暴露

//接口中的私有方法
//这个私有方法是给接口内部的其他方法调用的，不是给外部使用的
interface Test1 {
    default void test() {
        System.out.println("我是test方法默认实现");
        this.inner();   //接口中方法的默认实现可以直接调用接口中的私有方法
    }

    private void inner() {   //声明一个私有方法
        System.out.println("我是接口中的私有方法！");
    }
}