程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> JAVA編程 >> JAVA綜合教程 >> JAVA 8 Optional類介紹及其源碼,javaoptional

JAVA 8 Optional類介紹及其源碼,javaoptional

編輯:JAVA綜合教程

JAVA 8 Optional類介紹及其源碼,javaoptional


什麼是Optional對象

Java 8中所謂的Optional對象,即一個容器對象,該對象可以包含一個null或非null值。如果該值不為null,則調用isPresent()方法將返回true,且調用get()方法會返回該值。

另外,該對象還有其它方法:

如可以使用orElse()方法給Optional對象設定默認值(當值為null時,會使用默認值);

使用ifPresent()方法來執行一段代碼(當值不為null時,執行代碼段)。

Optional主要被用於Java 8的Stream中,簡單舉個例子:

package optional;

import java.util.Optional;
import java.util.stream.Stream;

public class Snippet
{
    public static void main(String[] args)
    {
        Stream<String> names = Stream.of("Lamurudu", "Okanbi", "Oduduwa");
        
        Optional<String> startswl = names.filter(name -> name.startsWith("L")).findFirst();
        
        //判斷是否不為null
        if(startswl.isPresent()){
            System.out.println(startswl.get());
        }
        
        //if值為null:打印“null”;if值不為null:打印原值
        System.out.println(startswl.orElse("null"));

        //if值不為null,執行Lambda表達式
        startswl.ifPresent(name -> {
            String s = name.toUpperCase();
            System.out.println(s);
        });
    }
}

使用Optional對象的好處

減少NullPointerException異常

寫出更加優雅的代碼

源碼及示例

Optional類的屬性和方法如下:

 

我們一個個看,先看兩個成員屬性;

成員屬性

如下,一個是EMPTY常量,即存放空值的Optional對象,另一個是value,即被存放的值,可為null或非null值;

    /**
     * Common instance for {@code empty()}.
     */
    private static final Optional<?> EMPTY = new Optional<>();

    /**
     * If non-null, the value; if null, indicates no value is present
     */
    private final T value;

構造方法

兩個構造方法,注意都是私有的

1、創建一個包含空值的Optional對象;

2、創建一個非空值的Optional對象;

    private Optional() {
        this.value = null;
    }
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

empty()方法

這個方法很簡單,作用是返回一個Optional實例,裡面存放的value是null,源碼如下:

    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

of(T value)方法

很簡單,就是返回一個包含非空值的Optional對象

    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

ofNullable(T value)方法

 很簡單,返回一個可以包含空值的Optional對象

    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

get()方法

 得到Optional對象裡的值,如果值為null,則拋出NoSuchElementException異常

    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

isPresent()方法

很簡單,判斷值是否不為null

    public boolean isPresent() {
        return value != null;
    }

ifPresent(Consumer<? super T> consumer)方法

 當值不為null時,執行consumer

    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

舉個例子,ifPresent方法執行Lambda表達式,將值轉換為大寫並打印:

package optional;

import java.util.Optional;

public class Snippet
{
    public static void main(String[] args)
    {
        Optional<String> test = Optional.ofNullable("abcDef");
        
        //值不為null,執行Lambda表達式,
        test.ifPresent(name -> {
            String s = name.toUpperCase();
            System.out.println(s);
        });
        //打印ABCDEF
    }
}

filter(Predicate<? super T> predicate)方法

看方法名就知道,該方法是過濾方法,過濾符合條件的Optional對象,這裡的條件用Lambda表達式來定義,

如果入參predicate對象為null將拋NullPointerException異常,

如果Optional對象的值為null,將直接返回該Optional對象,

如果Optional對象的值符合限定條件(Lambda表達式來定義),返回該值,否則返回空的Optional對象

源碼如下:

    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }

使用示例:

package optional;

import java.util.Optional;

public class Snippet
{
    public static void main(String[] args)
    {
        Optional<String> test = Optional.ofNullable("abcD");
        
        //過濾值的長度小於3的Optional對象
        Optional<String> less3 = test.filter((value) -> value.length() < 3);
        //打印結果
        System.out.println(less3.orElse("不符合條件,不打印值!"));
    }
}

map(Function<? super T, ? extends U> mapper)方法

 前面的filter方法主要用於過濾,一般不會修改Optional裡面的值,map方法則一般用於修改該值,並返回修改後的Optional對象

如果入參mapper對象為null將拋NullPointerException異常,

如果Optional對象的值為null,將直接返回該Optional對象,

最後,執行傳入的lambda表達式,並返回經lambda表達式操作後的Optional對象

    public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Optional.ofNullable(mapper.apply(value));
        }
    }

使用示例:

package optional;

import java.util.Optional;

public class Snippet
{
    public static void main(String[] args)
    {
        Optional<String> test = Optional.ofNullable("abcD");
        
        //將值修改為大寫
        Optional<String> less3 = test.map((value) -> value.toUpperCase());
        //打印結果 ABCD
        System.out.println(less3.orElse("值為null,不打印!"));
    }
}

flatMap(Function<? super T, Optional<U>> mapper)方法

flatMap方法與map方法基本一致,唯一的區別是,

如果使用flatMap方法,需要自己在Lambda表達式裡將返回值轉換成Optional對象,

而使用map方法則不需要這個步驟,因為map方法的源碼裡已經調用了Optional.ofNullable方法;

源碼:

    public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Objects.requireNonNull(mapper.apply(value));
        }
    }

使用示例:

package optional;

import java.util.Optional;

public class Snippet
{
    public static void main(String[] args)
    {
        Optional<String> test = Optional.ofNullable("abcD");
        
        //使用flatMap,將值修改為大寫
        Optional<String> less3 = test.flatMap((value) -> Optional.ofNullable(value.toUpperCase()));
        //使用map,將值修改為大寫
        //Optional<String> less3 = test.map((value) -> value.toUpperCase());
        
        //打印結果 ABCD
        System.out.println(less3.orElse("值為null,不打印!"));
    }
}

orElse(T other)方法

很簡單,當值為null時返回傳入的值,否則返回原值;

源碼:

    public T orElse(T other) {
        return value != null ? value : other;
    }

orElseGet(Supplier<? extends T> other)方法

功能與orElse(T other)類似,不過該方法可選值的獲取不是通過參數直接獲取,而是通過調用傳入的Lambda表達式獲取

源碼:

    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

使用示例:

package optional;

import java.util.Optional;

public class Snippet
{
    public static void main(String[] args)
    {
        Optional<String> test = Optional.ofNullable(null);

        System.out.println(test.orElseGet(() -> "hello"));
        //將打印hello
    }
}

orElseThrow(Supplier<? extends X> exceptionSupplier)方法

當遇到值為null時,根據傳入的Lambda表達式跑出指定異常

源碼

    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

使用示例:

package optional;

import java.util.Optional;

public class Snippet
{
    public static void main(String[] args)
    {
        Optional<String> test = Optional.ofNullable(null);

        //這裡的Lambda表達式為構造方法引用
        System.out.println(test.orElseThrow(NullPointerException::new));
        //將打印hello
    }
}

參考資料

jdk1.8.0_31源碼

https://blog.idrsolutions.com/2015/04/java-8-optional-class-explained-in-5-minutes/

https://www.voxxed.com/blog/2015/05/why-even-use-java-8-optional/

http://unmi.cc/proper-ways-of-using-java8-optional/

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved