Lambda

Optional类

/**
 * optional<T>类：容器类，代表一个值存在或不存在，原来用null表示一个值不存在，现在optional可以更好的表达这个概念，并且可以避免空指针异常
 * 常用方法：
 * Optional.of(T t):创建一个Optional实例
 * Optional.empty():创建一个空的Optional实例
 * Optional.ofNullable(T t):若t不为null，创建Optional实例，给否则创建空实例
 * isPresent():判断是否包含值
 * orElse(T t):如果调用对象包含值，返回该值，否则返回t
 * orElseGet(Supplier s):如果调用对象包含值，返回该值，否则返回s获取的值
 * map(Function f):如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty()
 * flatMap(Function mapper):与map类似，要求返回值必须是Optional
 */
public class TestLambda8 {

    /**
     * ForkJoin框架
     */
    @Test
    public void test1(){
        Optional<Employee> optional = Optional.of(new Employee());
        System.out.println(optional.get());

        //空指针异常，of不可构建null对象
//        Optional<Employee> optional1 = Optional.of(null);
//        System.out.println(optional1.get());


        Optional<Employee> optional2 = Optional.empty();
        //NoSuchElementException
        System.out.println(optional2.get());

        //等同于 Optional.of(new Employee())
        Optional<Employee> optional3 = Optional.ofNullable(new Employee());
        System.out.println(optional3.get());

        //等同于 Optional.empty()
        Optional<Employee> optional4 = Optional.ofNullable(null);
        System.out.println(optional4.get());


    }

    //包含值，返回该值，否则返回默认值,避免空指针异常
    @Test
    public void test2(){
        Optional<Employee> optional = Optional.ofNullable(null);

//        if(optional.isPresent()){
//            System.out.println(optional.get());
//        }
        Employee employee = optional.orElse(new Employee("张三", 20));
        System.out.println(employee);

        Optional<Employee> optional1 = Optional.ofNullable(new Employee());
//        if(optional1.isPresent()){
//            System.out.println(optional1.get());
//        }
        Employee employee1 = optional1.orElse(new Employee("张三", 20));
        System.out.println(employee1);
    }

    //进行函数赋值
    @Test
    public void test3(){
        Optional<Employee> optional = Optional.ofNullable(null);
        Employee employee = optional.orElseGet(() -> new Employee());
        System.out.println(employee);

        Optional<Employee> optional1 = Optional.ofNullable(new Employee("zhangsan",24));
        Employee employee1 = optional1.orElseGet(() -> new Employee());
        System.out.println(employee1);

    }

    @Test
    public void test4(){
        Optional<Employee> optional = Optional.ofNullable(new Employee("zhangsan",24));
        Optional<String> s = optional.map(e -> e.getName());
        System.out.println(s.get());

        Optional<Employee> optional1 = Optional.ofNullable(new Employee("zhangsan",24));
        Optional<String> employee1 = optional1.flatMap(e -> Optional.of(e.getName()));
        System.out.println(employee1.get());

    }

接口中的默认方法与静态方法

    /***
     * java8 接口中允许存在具体实现的方法，接口中的默认方法：类优先原则：
     * 若一个接口中定义了默认方法，另一个父类或接口中又定义了一个同名的方法时
     * 选择父类中的方法，若父类提供了具体实现，那么接口中具有相同名称和参数的默认方法会被忽略
     * 接口冲突，若一个父接口提供一个默认方法，而另一个接口也提供了相同名称和参数列表的方法（不管方法是不是默认方法），必须覆盖该方法来解决冲突
     */
    interface MyFun{
        default String getName(){
            return "hahaha";
        }
    }

    class MyClass{
        public String getName(){
            return "hehehe";
        }
    }

    class SubClass extends MyClass implements MyFun{

    }

    //类优先
    @Test
    public void test5(){
        SubClass subClass=new SubClass();
        System.out.println(subClass.getName());

    }

    interface MyInterface{
        default String getName(){
            return "gagaga";
        }

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

    class ChildClass  implements MyFun,MyInterface{

        @Override
        public String getName() {
            return MyFun.super.getName();
        }
    }

    //接口冲突
    @Test
    public void test6(){
        SubClass subClass=new SubClass();
        System.out.println(subClass.getName());
    }

    //静态方法应用
    @Test
    public void test7(){
        MyInterface.show();

    }

}

下一篇 Java8 时间与日期