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); }); } }
減少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); }
這個方法很簡單,作用是返回一個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 } }