jdk1.8新特性(四)——Optional

在我们的开发中，NullPointerException可谓是随时随处可见，为了避免空指针异常，我们常常需要进行一

些防御式的检查，所以在代码中常常可见if(obj != null) 这样的判断。JDK1.8为我们提供了

一个Optional类，Optional类能让我们省掉繁琐的非空的判断。

Optional中的方法汇总

使用示例：

package com.example.jdknewuse;

import java.util.Optional;

/**
 * @author: liumengbing
 * @date: 2019/02/21 19:51
 **/
public class OptionalTest {

    public static void main(String[] args){

        /**
         * of()方法
         */
        //创建一个值为张三的String类型的Optional
        Optional<String> ofOptional = Optional.of("张三");
        //如果我们用of方法创建Optional对象时，所传入的值为null，则抛出NullPointerException
        Optional<String> nullOptional = Optional.of(null);

        /**
         * ofNullable()方法
         */
        //为指定的值创建Optional对象，不管所传入的值为null不为null，创建的时候都不会报错
        Optional<String> nullOptional = Optional.ofNullable(null);
        Optional<String> nullOptional = Optional.ofNullable("lisi");

        /**
         * empty()方法
         */
        //创建一个空的String类型的Optional对象
        Optional<String> emptyOptional = Optional.empty();

        /**
         * get()方法:
         *  如果我们创建的Optional对象中有值存在则返回此值，如果没有值存在，则会抛出NoSuchElementException异常。
         */
        Optional<String> stringOptional = Optional.of("张三");
        System.out.println(stringOptional.get());
        //注意：若Optional是空的，调用get()方法则会抛出NoSuchElementException异常
        Optional<String> emptyOptional2 = Optional.empty();
        System.out.println(emptyOptional.get());

        /**
         * orElse()方法：
         *  如果创建的Optional中有值存在，则返回此值，否则返回一个默认值
         */
        Optional<String> stringOptional = Optional.of("张三");
        System.out.println(stringOptional.orElse("zhangsan"));
        Optional<String> emptyOptional = Optional.empty();
        System.out.println(emptyOptional.orElse("李四"));

        /**
         * orElseGet()方法：
         *  如果创建的Optional中有值存在，则返回此值，否则返回一个由Supplier接口生成的值
         */
        Optional<String> stringOptional = Optional.of("张三");
        System.out.println(stringOptional.orElseGet(() -> "zhangsan"));
        Optional<String> emptyOptional = Optional.empty();
        System.out.println(emptyOptional.orElseGet(() -> "orElseGet"));

        /**
         * orElseThrow()方法：
         *  如果创建的Optional中有值存在，则返回此值，否则抛出一个由指定的Supplier接口生成的异常
         */
        Optional<String> stringOptional = Optional.of("张三");
        System.out.println(stringOptional.orElseThrow(CustomException::new));
        Optional<String> emptyOptional = Optional.empty();
        System.out.println(emptyOptional.orElseThrow(CustomException::new));

        private static class CustomException extends RuntimeException {
            private static final long serialVersionUID = -4399699891687593264L;

            public CustomException() {
                super("自定义异常");
            }

            public CustomException(String message) {
                super(message);
            }
        }

        /**
         * filter()方法：
         *  如果创建的Optional中的值满足filter中的条件，则返回包含该值的Optional对象，否则返回一个空的Optional对象;
         *
         *  注意:
         *  Optional中的filter方法和Stream中的filter方法是有点不一样的，Stream中的filter方法是对一堆元素进
         *  行过滤，而Optional中的filter方法只是对一个元素进行过滤，可以把Optional看成是最多只包含一个元素的Stream。
         */
        Optional<String> stringOptional = Optional.of("zhangsan");
        System.out.println(stringOptional.filter(e -> e.length() > 5).orElse("王五"));
        stringOptional = Optional.empty();
        System.out.println(stringOptional.filter(e -> e.length() > 5).orElse("lisi"));

        /**
         * map()方法：
         *  如果创建的Optional中的值存在，对该值执行提供的Function函数调用
         */
        //map方法执行传入的lambda表达式参数对Optional实例的值进行修改,修改后的返回值仍然是一个Optional对象
        Optional<String> stringOptional = Optional.of("zhangsan");
        System.out.println(stringOptional.map(e -> e.toUpperCase()).orElse("失败"));
        stringOptional = Optional.empty();
        System.out.println(stringOptional.map(e -> e.toUpperCase()).orElse("失败"));

        /**
         * flatMap()方法：
         * 如果创建的Optional中的值存在，就对该值执行提供的Function函数调用，返回一个Optional类型的值，否
         * 则就返回一个空的Optional对象.flatMap与map（Funtion）方法类似，区别在于flatMap中的mapper返回值必须是Optional，
         * map方法的mapping函数返回值可以是任何类型T。调用结束时，flatMap不会对结果用Optional封装
         */
        //map方法中的lambda表达式返回值可以是任意类型，在map函数返回之前会包装为Optional。但flatMap方法中的lambda表达式返回值必须是Optionl实例
        Optional<String> stringOptional = Optional.of("zhangsan");
        System.out.println(stringOptional.flatMap(e -> Optional.of("lisi")).orElse("失败"));
        stringOptional = Optional.empty();
        System.out.println(stringOptional.flatMap(e -> Optional.empty()).orElse("失败"));

        /**
         * ifPresent()方法
         */
        //ifPresent方法的参数是一个Consumer的实现类，Consumer类包含一个抽象方法，该抽象方法对传入的值进行处理，只处理没有返回值。
        Optional<String> stringOptional = Optional.of("tom");
        System.out.println(stringOptional.get());//tom
        stringOptional.ifPresent(e-> {
            e = e + "sub";
            System.out.println(e);//tomsub
        });
        System.out.println(stringOptional.get());//tom
    }
}
           

特别说明：

of方法，就是提供一个static方法，方法名称叫of，方法的返回值返回当前类，并且把构造函数设置为私有private，用静态of方法来代替构造函数。

public class User {
    private String username;
    private Integer age;
    private User() {
    }
    public static User of() {
        return new User();
    }
    private User(String username, Integer age) {
        this.username = username;
        this.age = age;
    }
    public static User of(String username, Integer age) {
        return new User(username, age);
    }
}