java 8新特性学习系列(3):Optional类

java 8 Optional类

Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。

Optional 类的引入很好的解决空指针异常。

Optional类能让我们省掉繁琐的非空判断.

方法	描述
of	把指定的值封装为Optional对象,如果指定的值为null,则会抛出NullPointerException
empty	创建一个空的Optional对象
ofNullable	把指定的值封装为Optional对象如果指定的值为null则创建一个空的Optional对象
get	如果创建的Optional中有值存在,则返回此值,否则抛出NoSuchEleException
orElse	如果创建的Optional中有值存在,则返回此值,否则返回一个默认值
orElseGet	如果创建的Optional中有值存在,则返回此值,否则返回一个有SUpplier接口生成的值
orElseThrow	如果创建的Optional中有值存在,则返回此值,否则抛出一个由指定的Supplier接口生成的异常
filter	如果创建的Optional中的值满足filter中的条件,则返回包含该值的Optional对象,否则返回一个空的Optional对象
map	如果创建的Optional中的值存在,对该值执行提供的Function函数调用
flagMap	如果闯将的Optional中的值存在,就对该值执行提供的Function函数调用,返回一个Optional类型的值,否则就返回一个空的Optional
isPresent	如果创建的Optional中的值存在,返回true,否则返回false
ifPresent	如果创建的Optional中的值存在,则执行该方法的调用,否则什么都不做

of

   @Test
    public void ftest(){
        User user = new User();
        user.setAge(33);
        user.setName("小路");
        Optional<User> user1 = Optional.of(user);
       // -------------------------------------------------
        Optional.of(null);
        //会报错报错信息:
        //java.lang.NullPointerException
	    //at java.util.Objects.requireNonNull(Objects.java:203)
    	//at java.util.Optional.<init>(Optional.java:96)
	    //at java.util.Optional.of(Optional.java:108)
    }

empty

        Optional<Object> empty = Optional.empty();

ofNullable

        Optional<Object> o = Optional.ofNullable(null);
        Optional<User> user1 = Optional.ofNullable(user);

get
如果我们创建的Optional对象中有值存在则返回此值，如果没有值存在，则会抛出
NoSuchElementException异常

        User user = new User();
        user.setAge(33);
        user.setName("小路");
        User user1 = Optional.ofNullable(user).get();
        
        String s = Optional.of("张三").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

    @Test
    public void ftest(){
        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);
        }
    }
    //张三
	//com.lxq.AppTest$CustomException: 自定义异常

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"));
//zhangsan
//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("失败"));
//ZHANGSAN
//失败

flagmap

    @Test
    public void ftest() {
        //map方法中的lambda表达式返回值可以是任意类型，在map函数返回之前会包装为Optional。
        // 但flatMap方法中的lambda表达式返回值必须是Optionl实例
        Optional<String> stringOptional = Optional.of("zhangsan");
        System.out.println(stringOptional.flatMap(e -> Optional.of("lixq")).orElse("失败"));
        stringOptional = Optional.empty();
        System.out.println(stringOptional.flatMap(e -> Optional.empty()).orElse("失败"));
    }
    //lixq
    //失败

ifPresent

    @Test
    public void ftest() {
        //ifPresent方法的参数是一个Consumer的实现类，Consumer类包含一个抽象方法，
        // 该抽象方法对传入的值进行处理，只处理没有返回值。
         Optional<String> stringOptional = Optional.of("lixq");
         stringOptional.ifPresent(e-> System.out.println("我在。。。"+e));

    }