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();
    }
}