Java8新特性——Optional类

        Optional<T>类(java.util.Optional)是一个容器类，代表一个值存在或不存在，原来用null表示一个值不存在，现在Optiolal可以更好地表达这个概念。并且可以避免空指针异常。

        也就是说调用一个方法得到了一个返回值却不能直接将返回值作为参数去调用别的方法，我们首先要判断这个返回值是否为空，只有在非空的情况下才能将其作为其它方法的参数。       

Optional容器类的常用方法:
   1、Optional.of(T t):创建一个Optional实例，需要注意的是，创建对象时传入的参数不能为null。如果传入参数为null，则抛出NullPointerException 。
   2、Optional.empty():创建一个空的Optional实例
   3、Optional.ofNullable(T t):若t不为null，创建Optional实例，否则创建空实例
   4、isPresent():判断是否包含值
   5、orElse(T t):如果调用对象包含值，返回该值，否则返回t
   6、orElseGet(Supplier s):如果调用对象包含值，返回该值，否则返回s获取该值
   7、map(Function f):如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty()
   8、flatMap(Function mapper):与map类似，要求返回值必须是Optional

 @Test
    public void fun1(){
//      调用工厂方法创建Optional实例
//        java.util.Optional<Employee> optional = java.util.Optional.of(new Employee());
        java.util.Optional<Employee> of = java.util.Optional.of(null);
//        Employee employee = optional.get();
        Employee employee = of.get();
        System.out.println(employee);
    }
    @Test
    public void fun2(){
        java.util.Optional<Object> empty = java.util.Optional.empty();
        System.out.println(empty.get());
    }
    @Test
    public void fun3(){
//        java.util.Optional<Employee> ofNullable = java.util.Optional.ofNullable(new Employee());
        java.util.Optional<Employee> ofNullable = java.util.Optional.ofNullable(null);
//        如果有值就get一个,没有值的话就拿默认值
        if (ofNullable.isPresent()){
            System.out.println(ofNullable.get());
        }
        Employee orElse = ofNullable.orElse(new Employee("张三", 18, 888.88, Employee.Status.BUSY));
        System.out.println(orElse);

        Employee orElseGet = ofNullable.orElseGet(() -> new Employee("李四", 18, 666.66, Employee.Status.BUSY));
        System.out.println(orElseGet);
    }
    @Test
    public void fun4(){
        java.util.Optional<Employee> ofNullable = java.util.Optional.ofNullable(new Employee("张三", 18, 888.88, Employee.Status.BUSY));
        java.util.Optional<String> map = ofNullable.map((e) -> e.getName());
        System.out.println(map.get());

        java.util.Optional<String> flatmap = ofNullable.flatMap((e) -> java.util.Optional.of(e.getName()));
        System.out.println(flatmap.get());
    }

案例： 

package optional;

public class Person {
    private Fruits fruits;

    public Person() {
    }

    public Person(Fruits fruits) {
        this.fruits = fruits;
    }

    public Fruits getFruits() {
        return fruits;
    }

    public void setFruits(Fruits fruits) {
        this.fruits = fruits;
    }

    @Override
    public String toString() {
        return "Person{" +
                "fruits=" + fruits +
                '}';
    }
}

package optional;

public class Fruits {
    private String name;

    public Fruits() {
    }

    public Fruits(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Fruits{" +
                "name='" + name + '\'' +
                '}';
    }
}

package optional;

import java.util.Optional;

public class new_Person {
    private Optional<Fruits> optional = Optional.empty();

    public new_Person() {
    }

    public new_Person(Optional<Fruits> optional) {
        this.optional = optional;
    }

    public Optional<Fruits> getOptional() {
        return optional;
    }

    public void setOptional(Optional<Fruits> optional) {
        this.optional = optional;
    }

    @Override
    public String toString() {
        return "new_Person{" +
                "optional=" + optional +
                '}';
    }
}

package optional;

import org.junit.Test;

import java.util.Optional;

public class Examples{

    @Test
    public void fun1(){
        Person person = new Person();
        String fruitsName = getFruitsName(person);
        System.out.println(fruitsName);
    }
//   需求:获取人喜欢吃的水果的名字
    public String getFruitsName(Person person){
//        会发生空指针异常
        //        return person.getFruits().getName();

        if (person != null){
            Fruits fruits = person.getFruits();
            if (fruits != null){
                return fruits.getName();
            }
        }
        return "Banana";
    }

//    Optional类去书写
@Test
public void fun2(){
    Optional<new_Person> op = Optional.ofNullable(null);
    String s = getFruitsName1(op);
    System.out.println(s);
}
    public String getFruitsName1(Optional<new_Person> person){
        return person.orElse(new new_Person())
                      .getOptional()
                      .orElse(new Fruits("Banana"))
                      .getName();
    }
}