Java--8--新特性--Optional--有效防止空指針異常

Optional<T> 類(java.util.Optional) 是一個容器類，代表一個值存在或不存在，原來用 null 表示一個值不存在，現在 Optional 可以更好的表達這個概念。並且可以避免空指針異常。

下面是這個類的一些常用方法!

package OptionalP;

import LambdaP.Employee;
import org.junit.Test;
import java.util.Optional;

public class Optional1 {
    /*
     * 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
     */

    @Test
    public void test(){
        //Optional.of(T t) : 創建一個 Optional 實例
        Optional<Employee> employee = Optional.of(new Employee());
        System.out.println(employee.get());//LambdaP.Employee{name='null', age=0, salary=0}
        //of方法是不能構建一個null對象的，否則會報錯 NullPointerException 雖然報空指針，但是這時候我們就不需要一個個的Debug了，直接就能鎖定出錯行

        //Optional.empty() : 創建一個空的 Optional 實例
        Optional<Object> empty = Optional.empty();
        System.out.println(empty.get());
        //empty方法是構建一個新的空Optional對象，Optional中的內容是空的但是Optional對象不是空的，這時候調用get方法獲取內容會出錯
        //NoSuchElementException: No value present

        //Optional.ofNullable(T t):若 t 不為 null,創建 Optional 實例,否則創建空實例
        Optional<Object> o = Optional.ofNullable(null);
        System.out.println(o.get());
        //ofNullable是允許構建一個空對象的，但是同上面一個一樣，是無法獲取里面的值的，因為沒值
        //報錯java.util.NoSuchElementException: No value present

        //isPresent() : 判斷是否包含值
        Optional<Employee> employees = Optional.ofNullable(null);
        if(employees.isPresent()){
            System.out.println("不為空");
        }else {
            System.out.println("為空");
        }
        //為空  由此就可以看出，如果Optional中包含內容的話那么他會返回true，否則返回false

        //orElse(T t) :  如果調用對象包含值，返回該值，否則返回t
        Optional<Object> objectOptional = Optional.ofNullable(null);
        Object orElse = objectOptional.orElse(new Employee("orElse", 11, 1555));
        System.out.println(orElse);
        //LambdaP.Employee{name='orElse', age=11, salary=1555}  可以看出orElse作用了，如果是空就返回后面指定創建的，否則就返回ofNullable后封裝的對象


        //orElseGet(Supplier s) :如果調用對象包含值，返回該值，否則返回 s 獲取的值
        Optional<Object> o2 = Optional.ofNullable(null);
        Object o1 = o2.orElseGet(() -> 1);
        System.out.println(o1);
        // 1 orElseGet 里面是要求的是一個供給型接口Supplier  ，所以就可以根據我們的需求隨意的處理和返回任何東西

        //map(Function f): 如果有值對其處理，並返回處理后的Optional，否則返回 Optional.empty()
        Optional<Employee> o3 = Optional.ofNullable(new Employee("orElse", 11, 1555));
        Optional<Integer> integer = o3.map((e) -> e.getSalary() + 100000);
        System.out.println(integer);
        //Optional[101555]     現在就對封裝的對象中的工資進行了操作

        //flatMap(Function mapper):與 map 類似，要求返回值必須是Optional
        Optional<Employee> orElse4 = Optional.ofNullable(new Employee("orElse", 11, 1555));
        Optional<Integer> integer4 = orElse4.flatMap((e) -> Optional.ofNullable(e.getSalary() + 100000));
        System.out.println(integer4);
        //Optional[101555]
        //這里需要注意的是返回值必須是一個封裝以后的Optional對象
    }
}

上面就是一些基本的Optional的操作方法！