給女朋友講解什麼是Optional【JDK 8特性】

JDK · 發表 2018-11-19 21:03:00

摘要：前言只有光頭才能變強前兩天帶女朋友去圖書館了，隨手就給她來了一本《與孩子一起學程式設計》的書，於是今天就給女朋友講解一下什麼是Optional類。至於她能不能看懂，那肯定是看不懂的。(學到變數/for迴圈的女人怎麼能看懂呢) 不知道大家還記得上一篇《阿里...

前言

只有光頭才能變強

前兩天帶女朋友去圖書館了，隨手就給她來了一本《與孩子一起學程式設計》的書，於是今天就給女朋友講解一下什麼是Optional類。

至於她能不能看懂，那肯定是看不懂的。(學到變數/for迴圈的女人怎麼能看懂呢)

不知道大家還記得上一篇 ofollow,noindex" target="_blank">《阿里巴巴 Java開發手冊》讀後感不，當時閱讀到空指標異常(NPE)時，書上提到JDK 8有個Optional類供我們使用，該類可以儘可能地防止出現空指標異常(NPE)。

文字 力求簡單講清每個知識點 ，希望大家看完能有所收穫

一、基礎鋪墊

我們都知道JDK 8最重要的新特性是 Lambda 表示式，這個可以讓我們簡化非常多的程式碼編寫，不知道大家會使用了沒有。這裡我簡單跟大家來回顧一下~

1.1Lambda簡化程式碼例子

下面就以 幾個例子 來看看Lambda表示式是怎麼簡化我們程式碼的編寫的。

首先我們來看看 建立執行緒 ：

public static void main(String[] args) {
// 用匿名內部類的方式來建立執行緒
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("公眾號：Java3y---回覆1進群交流");
}
});

// 使用Lambda來建立執行緒
new Thread(() -> System.out.println("公眾號：Java3y---回覆1進群交流"));
}

再來看看遍歷Map集合：

public static void main(String[] args) {
Map<String, String> hashMap = new HashMap<>();
hashMap.put("公眾號", "Java3y");
hashMap.put("交流群", "回覆1");

// 使用增強for的方式來遍歷hashMap
for (Map.Entry<String, String> entry : hashMap.entrySet()) {
System.out.println(entry.getKey()+":"+entry.getValue());
}

// 使用Lambda表示式的方式來遍歷hashMap
hashMap.forEach((s, s2) -> System.out.println(s + ":" + s2));
}

在List中刪除某個元素

public static void main(String[] args) {

List<String> list = new ArrayList<>();
list.add("Java3y");
list.add("3y");
list.add("光頭");
list.add("帥哥");

// 傳統的方式刪除"光頭"的元素
ListIterator<String> iterator = list.listIterator();
while (iterator.hasNext()) {
if ("光頭".equals(iterator.next())) {
iterator.remove();
}
}

// Lambda方式刪除"光頭"的元素
list.removeIf(s -> "光頭".equals(s));

// 使用Lambda遍歷List集合
list.forEach(s -> System.out.println(s));
}

從上面的例子我們可以看出，Lambda表示式的確是可以幫我們簡化程式碼的。

1.1函式式介面

使用Lambda表示式，其實都是建立在 函式式介面 上的。我們看看上面的程式碼的介面：

建立多執行緒的Runnable介面：

@FunctionalInterface
public interface Runnable {
public abstract void run();
}

遍歷HashMap的BiConsumer介面：

@FunctionalInterface
public interface BiConsumer<T, U> {
void accept(T t, U u);
default BiConsumer<T, U> andThen(BiConsumer<? super T, ? super U> after) {
Objects.requireNonNull(after);
return (l, r) -> {
accept(l, r);
after.accept(l, r);
};
}
}

在List中刪除元素的Predicate介面：

@FunctionalInterface
public interface Predicate<T> {

boolean test(T t);

default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate<T> negate() {
return (t) -> !test(t);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}

函式式介面的特點：由 @FunctionalInterface 註解標識，介面 有且僅有 一個抽象方法！

1.2Lambda簡單講解

或許我們一開始看到Lambda的時候，發現Lambda表示式的語法有點奇葩，甚至有點看不懂。沒事，這裡3y給大家用圖的形式畫一畫：

以Runnable介面來舉例：

再不濟，我們在用IDE的時候，可以提示出Lambda表示式的語法的，這樣可以幫我們快速上手Lambda表示式：

說白了，我們使用Lambda表示式的架子是這樣的 ()->{} ，具體的時候看看函式式介面的抽象方法要求就可以了，再不濟就使用IDE智慧提示。

1.3泛型回顧

比如說 public<U> Optional<U> map(Function<? super T, ? extends U> mapper) 這個宣告，你看懂了嗎？

// 介面
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}

在泛型的上限和下限中有一個原則：PECS(Producer Extends Consumer Super)

帶有子類限定的可以從泛型讀取【也就是--->(? extend T)】-------->Producer Extends
帶有超類限定的可以從泛型寫入【也就是--->(? super T)】-------->Consumer Super

解析：傳入的引數是泛型 T 或者其父類，返回值是U或其子類。

具體可參考：

泛型就這麼簡單

二、Optional類

一句話介紹Optional類：使用JDK8的Optional類來防止NPE(空指標異常)問題。

接下來我們看看文件是怎麼說的：

A container object which may or may not contain a non-null value.Additional methods that depend on the presence or absence of a contained value are provided

它是一個容器，裝載的物件可以是null，也可以是非null，提供了一系列的方法供我們判斷該容器裡的物件是否存在(以及後續的操作)。

Optional類的方法結構圖：

2.1建立Optional容器

我們先來看看Optional的屬性以及建立Optional容器的方法：

// 1、創建出一個Optional容器，容器裡邊並沒有裝載著物件
private static final Optional<?> EMPTY = new Optional<>();

// 2、代表著容器中的物件
private final T value;

// 3、私有構造方法
private Optional() {
this.value = null;
}

// 4、得到一個Optional容器，Optional沒有裝載著物件
public static<T> Optional<T> empty() {
@SuppressWarnings("unchecked")
Optional<T> t = (Optional<T>) EMPTY;
return t;
}

// 5、私有構造方法(帶引數)，引數就是具體的要裝載的物件，如果傳進來的物件為null，丟擲異常
private Optional(T value) {
this.value = Objects.requireNonNull(value);
}

// 5.1、如果傳進來的物件為null，丟擲異常
public static <T> T requireNonNull(T obj) {
if (obj == null)
throw new NullPointerException();
return obj;
}


// 6、創建出Optional容器，並將物件(value)裝載到Optional容器中。
// 傳入的value如果為null，丟擲異常(呼叫的是Optional(T value)方法)
public static <T> Optional<T> of(T value) {
return new Optional<>(value);
}

// 創建出Optional容器，並將物件(value)裝載到Optional容器中。
// 傳入的value可以為null，如果為null，返回一個沒有裝載物件的Optional物件
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
}

所以可以得出建立Optional容器有兩種方式：

呼叫ofNullable()方法，傳入的物件可以為null
呼叫of()方法，傳入的物件不可以為null，否則丟擲NullPointerException

下面我們簡單就可以看看用法了：

現在我有一個User物件，這裡用到了Lombok，有興趣的同學可去學學瞭解一下：兩個月的Java實習結束，繼續努力

import lombok.Data;
@Data
public class User {

private Integer id;
private String name;
private Short age;
}

測試：

public static void main(String[] args) {

User user = new User();
User user1 = null;

// 傳遞進去的物件不可以為null，如果為null則丟擲異常
Optional<User> op1 = Optional.of(user1);

// 傳遞進去的物件可以為null，如果為null則返回一個沒有裝載物件的Optional容器
Optional<User> op2 = Optional.ofNullable(user);
}

2.2Optional容器簡單的方法

// 得到容器中的物件，如果為null就丟擲異常
public T get() {
if (value == null) {
throw new NoSuchElementException("No value present");
}
return value;
}

// 判斷容器中的物件是否為null
public boolean isPresent() {
return value != null;
}

// 如果容器中的物件存在，則返回。否則返回傳遞進來的引數
public T orElse(T other) {
return value != null ? value : other;
}

這三個方法是Optional類比較常用的方法，並且是最簡單的。(因為引數不是函式式介面)

下面我們繼續看看用法：

public static void main(String[] args) {

User user = new User();
User user1 = null;

Optional<User> op1 = Optional.ofNullable(user);
System.out.println(op1.isPresent());
System.out.println(op1.get());
System.out.println(op1.orElse(user1));

}

結果很明顯，因為我們的user是不為null的：

我們調換一下順序看看：

public static void main(String[] args) {

User user = new User();
User user1 = null;

Optional<User> op1 = Optional.ofNullable(user1);
System.out.println(op1.isPresent());
System.out.println(op1.orElse(user));
System.out.println(op1.get());

}

2.3Optional容器進階用法

當然了，我們到目前為止看起來Optional類好像就這麼一回事了，這樣程式碼寫起來還不如我自己判斷null呢...

我們對比一下：

我們可以發現，手動判斷是否為null好像還更方便簡潔一點呢。

所以，我們帶函式式介面的方法登場了！

2.3.1ifPresent方法

首先來看看 ifPresent(Consumer<? super T> consumer) 方法

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

@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
}

如果容器中的物件存在，則呼叫accept方法，比如說：

public static void main(String[] args) {

User user = new User();
user.setName("Java3y");
test(user);
}

public static void test(User user) {

Optional<User> optional = Optional.ofNullable(user);

// 如果存在user，則列印user的name
optional.ifPresent((value) -> System.out.println(value.getName()));

// 舊寫法
if (user != null) {
System.out.println(user.getName());
}
}

2.3.2orElseGet和orElseThrow方法

直接看原始碼：

// 如果物件存在，則直接返回，否則返回由Supplier介面的實現用來生成預設值
public T orElseGet(Supplier<? extends T> other) {
return value != null ? value : other.get();
}


@FunctionalInterface
public interface Supplier<T> {
T get();
}


// 如果存在，則返回。否則丟擲supplier介面建立的異常
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
if (value != null) {
return value;
} else {
throw exceptionSupplier.get();
}
}

例子：

public static void main(String[] args) {

User user = new User();
user.setName("Java3y");
test(user);
}

public static void test(User user) {

Optional<User> optional = Optional.ofNullable(user);

// 如果存在user，則直接返回，否則創建出一個新的User物件
User user1 = optional.orElseGet(() -> new User());

// 舊寫法
if (user != null) {
user = new User();
}
}

總的來說跟我們上面所講的 orElse() 差不多，只不過它可以通過Supplier介面的實現來生成預設值。

2.3.3filter方法

直接看原始碼：

// 如果容器中的物件存在，並且符合過濾條件，返回裝載物件的Optional容器，否則返回一個空的Optional容器
public Optional<T> filter(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate);
if (!isPresent())
return this;
else
return predicate.test(value) ? this : empty();
}


// 介面
@FunctionalInterface
public interface Predicate<T> {

boolean test(T t);
}

返回Optional物件我們就可以實現 鏈式呼叫 了！

例子：

public static void test(User user) {

Optional<User> optional = Optional.ofNullable(user);

// 如果容器中的物件存在，並且符合過濾條件，返回裝載物件的Optional容器，否則返回一個空的Optional容器
optional.filter((value) -> "Java3y".equals(value.getName()));
}

2.3.4map方法

直接看原始碼：

// 如果容器的物件存在，則對其執行呼叫mapping函式得到返回值。然後建立包含mapping返回值的Optional，否則返回空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));
}
}


// 介面
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}

例子：

public static void test(User user) {

Optional<User> optional = Optional.ofNullable(user);

// 如果容器的物件存在，則對其執行呼叫mapping函式得到返回值。然後建立包含mapping返回值的Optional，否則返回空Optional。
optional.map(user1 -> user1.getName()).orElse("Unknown");
}

// 上面一句程式碼對應著最開始的老寫法：

public String tradition(User user) {
if (user != null) {
return user.getName();
}else{
return "Unknown";
}
}

2.3.5flatMap方法

直接看原始碼：

// flatMap方法與map方法類似，區別在於apply函式的返回值不同。map方法的apply函式返回值是? extends U，而flatMap方法的apply函式返回值必須是Optional
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));
}
}

2.3.6總結

再來感受一下Optional的魅力

public static void main(String[] args) {
User user = new User();
user.setName("Java3y");
System.out.println(test(user));
}

// 以前的程式碼v1
public static String test2(User user) {
if (user != null) {
String name = user.getName();
if (name != null) {
return name.toUpperCase();
} else {
return null;
}
} else {
return null;
}
}

// 以前的程式碼v2
public static String test3(User user) {
if (user != null && user.getName() != null) {
return user.getName().toUpperCase();
} else {
return null;
}
}

// 現在的程式碼
public static String test(User user) {
return Optional.ofNullable(user)
.map(user1 -> user1.getName())
.map(s -> s.toUpperCase()).orElse(null);
}

Optional總結：

filter，map或flatMap一個函式，函式的引數拿到的值一定不是null。所以我們通過filter，map 和 flatMap之類的函式可以將其安全的進行變換，最後通過orElse系列，get，isPresent 和 ifPresent將其中的值提取出來。

其實吧，用Optional類也沒有簡化很多的程式碼，只是把NPE異常通過各種方法隱藏起來(包裝了一層)。通過Lambda表示式可以讓我們處理起來更加" 優雅 "一些。

三、最後

之前在初學的時候沒在意JDK8的特性，其實JDK更新很多時候都能給我們帶來不少好處的(簡化程式碼編寫，提高效能等等)，所以作為一名Java程式員，還是得多學學新特性。(話說JDK9該類又有新特性了...)

如果你要評論“醒醒吧，程式設計師哪來的女朋友”，“我尿黃，讓我來”之類的話，我建議你是不是 好好反省 一下自己，為什麼別的程式設計師都有女朋友，就你沒有，是不是自己技術不過關了？通過“工廠”找一個有那麼難嗎？再不濟也能自己new一個出來啊。

當然了，我的女朋友是現實存在的。

參考資料：

Java 8 Optional類深度解析： https://www.cnblogs.com/xingzc/p/5778090.html
Java8 如何正確使用 Optional： http://www.importnew.com/26066.html
https://www.zhihu.com/question/63783295/answer/214531004
【Java】jdk8 Optional 的正確姿勢 https://blog.csdn.net/hj7jay/article/details/52459334

如果你覺得我寫得還不錯，瞭解一下：

堅持原創的技術公眾號：Java3y。回覆 1 加入Java交流群
文章的 目錄導航 (精美腦圖+海量視訊資源)： https://github.com/ZhongFuCheng3y/3y

給女朋友講解什麼是Optional【JDK 8特性】

前言

一、基礎鋪墊

1.1Lambda簡化程式碼例子

1.1函式式介面

1.2Lambda簡單講解

1.3泛型回顧

二、Optional類

2.1建立Optional容器

2.2Optional容器簡單的方法

2.3Optional容器進階用法

2.3.1ifPresent方法

2.3.2orElseGet和orElseThrow方法

2.3.3filter方法

2.3.4map方法

2.3.5flatMap方法

2.3.6總結

三、最後

您可能也會喜歡…