1、概述

Java8的版本，新增了Optional和[Lambda]表達(dá)式，Optional主要用于作為返回類型（主要解決的問題是臭名昭著的空指針異常

（NullPointerException）），并將其與流(或返回可選的方法)相結(jié)合以構(gòu)建連貫API。但是，有些情況可以被認(rèn)為是陷阱，因為它們會降低代碼的質(zhì)量，甚至導(dǎo)致意想不到的錯誤。總結(jié)以下26個例子，以避免這些陷阱。

2、 目 錄

[第1項：決不將Null分配給可選變量]

[第2項：調(diào)用Optional.get（）之前，確保Optional具有值]

[第3項：當(dāng)不存在任何值時，通過Optional.orElse（）方法設(shè)置/返回已經(jīng)構(gòu)造的默認(rèn)對象]

[第4項：不存在任何值時，通過Optional.orElseGet（）方法設(shè)置/返回不存在的默認(rèn)對象]

[第5項：當(dāng)不存在任何值時，自Java 10起通過orElseThrow（）拋出java.util.NoSuchElementException異常]

[第6項：當(dāng)不存在任何值時，通過orElseThrow（Supplier <？extended X> exceptionSupplier）引發(fā)顯式異常]

[第7項：當(dāng)你有可選的并且需要空引用時，請使用orElse（null）]

[第8項：使用可選（如果存在）。如果不存在，則什么也不做。這是Optional.ifPresent（）的工作。]

[第9項：使用可選（如果存在）。如果不存在，請執(zhí)行基于空的操作。這是Optional.ifPresentElse（），Java 9的工作。]

[第10項：當(dāng)值存在時，設(shè)置/返回該可選項。如果不存在任何值，則設(shè)置/返回另一個可選項。這是Java 9的Optional.or（）的工作。]

[第11項：Optional.orElse / orElseXXX是Lambdas中的isPresent（）-get（）完美替代]

[第12項：避免僅出于獲取價值的目的而鏈接可選方法]

[第13項：不要聲明任何類型的可選字段]

[第14項：在構(gòu)造函數(shù)參數(shù)中不要使用可選]

[第15項：在Setters參數(shù)中不要使用可選]

[第16項：在方法參數(shù)中不要使用可選]

[第17項：不要使用Optional 的返回空的集合或數(shù)組]

[第18項：避免在集合中使用Optional]

[第19項：不要混淆Optional.of（）和Optional.ofNullable（）]

[第20項：避免使用可選的，并選擇非通用的OptionalInt，OptionalLong或OptionalDouble]

[第21項：無需包裝主張平等的任擇方案]

[第22項：通過Map（）和flatMap（）轉(zhuǎn)換值]

[第23項：使用filter（）根據(jù)預(yù)定義的規(guī)則拒絕包裝值]

[第24項：我們是否需要將可選API與流API鏈接在一起？]

[第25項：避免對可選選項使用身份敏感的操作]

[第26項：如果Optional為空，則返回一個布爾值。首選Java 11，Optional.isEmpty（）]

第1項：決不將Null分配給可選變量

避免：

// 避免public Optional<Cart> fetchCart() { Optional<Cart> emptyCart = null; ...}

首選：

// 首選public Optional<Cart> fetchCart() { Optional<Cart> emptyCart = Optional.empty(); ...}

首選Optional.empty()初始化 Optional而不是null值。Optional只是一個容器/盒子，用初始化它是沒有意義的null。

第2項：調(diào)用Optional.get（）之前，確保Optional具有值

如果出于某種原因你決定使用Optional.get()，那么請不要忘記必須Optional在此調(diào)用之前證明該值存在。通常，將通過基于該Optional.isPresent()方法添加檢查（條件）來執(zhí)行此操作。Optional.get()在某些時候容易被棄用。

避免：

// 避免Optional<Cart> cart = ... ; // 這很容易是空的...// 如果“cart”是空的，那么這段代碼將拋出一個java.util.NoSuchElementExceptionCart myCart = cart.get();

首選：

// 首選if (cart.isPresent()) { Cart myCart = cart.get(); ...} else { ... // 做一些不調(diào)用carter .get()的事情}第3項：當(dāng)不存在任何值時，通過Optional.orElse（）方法設(shè)置/返回已經(jīng)構(gòu)造的默認(rèn)對象

使用Optional.orElse()方法代表了用于設(shè)置/返回值的isPresent()-get()對的優(yōu)雅替代。這里重要的一點是，即使是非空可選的，也要計算oforElse()參數(shù)。這意味著即使不使用它，也會對它進行評估，這是一種性能損失。在這個上下文中，useorElse()只在參數(shù)(默認(rèn)對象)已經(jīng)構(gòu)造完成時才使用。在其他情況下，請依賴第4項。

避免：

// 避免public static final String USER_STATUS = 'UNKNOWN';...public String findUserStatus(long id) { Optional<String> status = ... ; // 容易返回一個空的 Optional if (status.isPresent()) { return status.get(); } else { return USER_STATUS; }}

首選：

// 首選public static final String USER_STATUS = 'UNKNOWN';...public String findUserStatus(long id) { Optional<String> status = ... ; // 容易返回一個空的 Optional return status.orElse(USER_STATUS);}第4項：不存在任何值時，通過Optional.orElseGet（）方法設(shè)置/返回不存在的默認(rèn)對象

使用theOptional.orElseGet()方法表示另一種用于設(shè)置/返回值的替代theisPresent()-get()對的優(yōu)雅方法。這里重要的一點是，參數(shù)oforElseGet()是Java 8新特性。這意味著作為參數(shù)傳遞的Suppliermethod只在Optionalvalue不存在時執(zhí)行。因此，這有助于避免創(chuàng)建對象和執(zhí)行在出現(xiàn)Optionalvalue時不需要的代碼時的orElse()性能損失。

避免：

// 避免public String computeStatus() { ... // 一些用來計算狀態(tài)的代碼}public String findUserStatus(long id) { Optional<String> status = ... ; // 容易返回一個空的 Optional if (status.isPresent()) { return status.get(); } else { return computeStatus(); }}

另外，請避免：

// 避免public String computeStatus() { ... // 一些用來計算狀態(tài)的代碼}public String findUserStatus(long id) { Optional<String> status = ... ; // 容易返回一個空的 Optional // 即使“status”不是空的，也會調(diào)用computeStatus() return status.orElse(computeStatus());}

首選：

public String computeStatus() { ... // some code used to compute status}public String findUserStatus(long id) { Optional<String> status = ... ; // 容易返回一個空的 Optional // 僅當(dāng)“status”為空時才調(diào)用computeStatus() return status.orElseGet(this::computeStatus);}第5項：當(dāng)不存在任何值時，自Java 10起通過orElseThrow（）拋出java.util.NoSuchElementException異常

使用該Optional.orElseThrow()方法代表了該方法的另一種優(yōu)雅替代方法isPresent()-get()。有時，當(dāng)Optional不存在值時，你要做的就是拋出java.util.NoSuchElementException異常。從Java 10開始，這可以通過orElseThrow()不帶參數(shù)的方法來完成。對于Java 8和9，請考慮第6項。

避免：

public String findUserStatus(long id) { Optional<String> status = ... ; // 容易返回一個空的 Optional if (status.isPresent()) { return status.get(); } else { throw new NoSuchElementException(); }}

首選：

public String findUserStatus(long id) { Optional<String> status = ... ; // 容易返回一個空的 Optional return status.orElseThrow();}第6項：當(dāng)不存在任何值時，通過orElseThrow（Supplier <？extended X> exceptionSupplier）引發(fā)顯式異常

在Java 10中，對于 java.util.NoSuchElementException，請使用 orElseThrow()，如第5項所示。使用該Optional.orElseThrow(Supplier&lt;? extends X&gt; exceptionSupplier)方法代表了該方法的另一種優(yōu)雅替代方法isPresent()-get()。有時，當(dāng)Optional不存在值時，你要做的就是拋出一個明確的異常。從Java 10開始，如果該異常java.util.NoSuchElementException僅依賴于orElseThrow()不帶參數(shù)的方法-第5項。

避免：

public String findUserStatus(long id) { Optional<String> status = ... ; // 容易返回一個空的 Optional if (status.isPresent()) { return status.get(); } else { throw new IllegalStateException(); }}

首選：

public String findUserStatus(long id) { Optional<String> status = ... ; // 容易返回一個空的 Optional return status.orElseThrow(IllegalStateException::new);}第7項：當(dāng)您有可選的并且需要空引用時，請使用orElse（null）

如果你有Optional需要提供null參考的，請使用 orElse(null)。否則，請避免 orElse(null)。orElse(null)當(dāng)我們有一個Optional，并且需要null在某些情況下調(diào)用一個接受引用的方法時，就會發(fā)生典型的使用情況。例如，讓我們看一下Method.invoke()Java Reflection API。此方法的第一個參數(shù)是要在其上調(diào)用此特定方法的對象實例。如果方法是static,第一個參數(shù)，則應(yīng)為null。

避免：

Method myMethod = ... ;...// 包含MyClass的實例，如果“myMethod”是靜態(tài)的，則為空Optional<MyClass> instanceMyClass = ... ;...if (instanceMyClass.isPresent()) { myMethod.invoke(instanceMyClass.get(), ...); } else { myMethod.invoke(null, ...); }

首選：

Method myMethod = ... ;...// 包含MyClass的實例，如果“myMethod”是靜態(tài)的，則為空Optional<MyClass> instanceMyClass = ... ;...myMethod.invoke(instanceMyClass.orElse(null), ...);第8項：使用可選（如果存在）。如果不存在，則什么也不做。這是Optional.ifPresent（）的工作。

當(dāng)你只需要使用值時，Optional.ifPresent（）是isPresent（）-get（）paid的不錯選擇。 如果沒有值，則不執(zhí)行任何操作。

避免：

Optional<String> status = ... ;...if (status.isPresent()) { System.out.println('Status: ' + status.get());}

首選：

Optional<String> status ... ;...status.ifPresent(System.out::println);第9項：使用可選（如果存在）。如果不存在，請執(zhí)行基于空的操作。這是Optional.ifPresentElse（），Java 9的工作。

從Java 9開始，它Optional.ifPresentOrElse()是isPresent()-get()配對的不錯選擇。這與ifPresent()方法類似， 只不過它也覆蓋else分支。

避免：

Optional<String> status = ... ;if(status.isPresent()) { System.out.println('Status: ' + status.get());} else { System.out.println('Status not found');}

首選：

Optional<String> status = ... ;status.ifPresentOrElse( System.out::println, () -> System.out.println('Status not found'));第10項：當(dāng)值存在時，設(shè)置/返回該可選項。如果不存在任何值，則設(shè)置/返回另一個可選項。這是Java 9的Optional.or（）的工作。

有時，對于非空， Optional,我們想設(shè)置/返回那個 Optional。當(dāng)我們Optional為空時，我們想執(zhí)行其他操作，該操作也返回一個 Optional。該orElse()和orElseGet()方法不能做到這一點，因為兩者都將返回展開值。現(xiàn)在該介紹Java 9 Optional.or()方法了，該方法能夠返回Optional描述值。否則，它將返回Optional提供功能產(chǎn)生的結(jié)果。

避免：

public Optional<String> fetchStatus() { Optional<String> status = ... ; Optional<String> defaultStatus = Optional.of('PENDING'); if (status.isPresent()) { return status; } else { return defaultStatus; } }

另外，請避免：

public Optional<String> fetchStatus() { Optional<String> status = ... ; return status.orElseGet(() -> Optional.<String>of('PENDING'));}

首選：

public Optional<String> fetchStatus() { Optional<String> status = ... ; Optional<String> defaultStatus = Optional.of('PENDING'); return status.or(() -> defaultStatus); // 或者，不定義“defaultStatus” return status.or(() -> Optional.of('PENDING'));}第11項：Optional.orElse / orElseXXX是Lambdas中的isPresent（）-get（）完美替代

這可用于獲取鏈接的lambda，而不是被破壞的代碼。考慮 ifPresent() 和 ifPresentOrElse() Java中9或 or() Java中9的方法，也是如此。某些特定于lambda的操作正在返回Optional（例如，findFirst(), findAny(), reduce(),...）。嘗試Optional通過該isPresent()-get()對使用此方法是一種笨拙的方法，因為它可能需要您打破lambda鏈，用if語句污染代碼，并考慮繼續(xù)使用鏈。在這種情況下，orElse()and和orElseXXX()非常方便，因為它們可以直接在lambda表達(dá)式鏈中鏈接，并避免破壞代碼。

例子1

避免：

List<Product> products = ... ;Optional<Product> product = products.stream() .filter(p -> p.getPrice() < price) .findFirst();if (product.isPresent()) { return product.get().getName();} else { return 'NOT FOUND';}

另外，請避免：

List<Product> products = ... ;Optional<Product> product = products.stream() .filter(p -> p.getPrice() < price) .findFirst();return product.map(Product::getName) .orElse('NOT FOUND');

首選：

List<Product> products = ... ;return products.stream() .filter(p -> p.getPrice() < price) .findFirst() .map(Product::getName) .orElse('NOT FOUND');

例子2

避免：

Optional<Cart> cart = ... ;Product product = ... ;...if(!cart.isPresent() || !cart.get().getItems().contains(product)) { throw new NoSuchElementException();}

首選：

Optional<Cart> cart = ... ;Product product = ... ;...cart.filter(c -> c.getItems().contains(product)).orElseThrow();第12項：避免僅出于獲取價值的目的而鏈接可選方法

有時，我們傾向于“過度使用”事物。意味著我們有一個東西，例如 Optional，并且到處都可以看到用例。在的情況下 Optional，常見的情況是出于獲得價值的單一目的而鏈接其方法。避免這種做法，而是依靠簡單明了的代碼。

避免：

public String fetchStatus() { String status = ... ; return Optional.ofNullable(status).orElse('PENDING');}

首選：

public String fetchStatus() { String status = ... ; return status == null ? 'PENDING' : status;}第13項：不要聲明任何類型的可選字段

請勿 Optional 在方法（包括 setters）或構(gòu)造函數(shù)參數(shù)中使用。

請記住，這Optional 并不是要用于字段，并且不會實現(xiàn)Serializable。該Optional班是明確不打算用作一個Java Bean的屬性。

避免：

public class Customer { [access_modifier] [static] [final] Optional<String> zip; [access_modifier] [static] [final] Optional<String> zip = Optional.empty(); ...}

首選：

public class Customer { [access_modifier] [static] [final] String zip; [access_modifier] [static] [final] String zip = ''; ...}第14項：在構(gòu)造函數(shù)參數(shù)中不要使用可選

請勿將其 Optional 用作字段或方法（包括 setters）的參數(shù)。

這是違背Optional意圖的另一種用法。 Optional用另一種抽象級別包裝對象，在這種情況下，只需添加額外的樣板代碼。

避免：

public class Customer { private final String name;// 不可能為null private final Optional<String> postcode; //可能為null public Customer(String name, Optional<String> postcode) { this.name = Objects.requireNonNull(name, () -> '名稱不能為空'); this.postcode = postcode; } public Optional<String> getPostcode() { return postcode; } ...}

首選：

public class Customer { private final String name; private final String postcode; public Cart(String name, String postcode) { this.name = Objects.requireNonNull(name, () -> '名稱不能為空'); this.postcode = postcode; } public Optional<String> getPostcode() { return Optional.ofNullable(postcode); } ...}

如你所見，getter現(xiàn)在返回 Optional。不要以這個示例作為轉(zhuǎn)換所有此類getter的規(guī)則。多數(shù)情況下，getter返回集合或數(shù)組，在這種情況下，他們更喜歡返回空集合/數(shù)組而不是 Optional。

我認(rèn)為，通常將其用作獲取方法的返回值肯定會過度使用。

第15項：在Setters參數(shù)中不要使用可選

Optional 不能用作Java Bean的屬性或持久屬性類型。 Optional 不是Serializable。Optional在二傳手中使用是另一種反模式。通常，我看到它用作持久屬性類型（將實體屬性映射為 Optional）。但是，可以O(shè)ptional在域模型實體中使用，如以下示例所示。

避免：

@Entitypublic class Customer implements Serializable { private static final long serialVersionUID = 1L; ... @Column(name='customer_zip') private Optional<String> postcode; // optional 字段, 因此可能為空 public Optional<String> getPostcode() { return postcode; } public void setPostcode(Optional<String> postcode) { this.postcode = postcode; } ...}

首選：

@Entitypublic class Customer implements Serializable { private static final long serialVersionUID = 1L; ... @Column(name='customer_zip') private String postcode; public Optional<String> getPostcode() { return Optional.ofNullable(postcode); } public void setPostcode(String postcode) { this.postcode = postcode; } ...}第16項：在方法參數(shù)中不要使用可選

不要 Optional 用作字段或設(shè)置器和構(gòu)造函數(shù)的參數(shù)。Optional在in方法中使用參數(shù)是另一個常見錯誤。這將導(dǎo)致不必要的復(fù)雜代碼。負(fù)責(zé)檢查參數(shù)，而不是強制調(diào)用站點創(chuàng)建 Optional。這種做法會使代碼混亂，并可能導(dǎo)致依賴性。隨著時間的流逝，您將在所有地方使用它。請記住，這Optional只是另一個對象（容器），而且價它消耗的內(nèi)存是強引用的4倍！但是，你可以用，視情況而定。

避免：

public void renderCustomer(Cart cart, Optional<Renderer> renderer, Optional<String> name) { if (cart == null) { throw new IllegalArgumentException('Cart不能為空'); } Renderer customerRenderer = renderer.orElseThrow( () -> new IllegalArgumentException('Renderer 不能為空') ); String customerName = name.orElseGet(() -> 'anonymous'); ...}//調(diào)用這個是錯誤的renderCustomer(cart, Optional.<Renderer>of(CoolRenderer::new), Optional.empty());

首選：

public void renderCustomer(Cart cart, Renderer renderer, String name) { if (cart == null) { throw new IllegalArgumentException('Cart 不能為空'); } if (renderer == null) { throw new IllegalArgumentException('Renderer 不能為空'); } String customerName = Objects.requireNonNullElseGet(name, () -> 'anonymous'); ...}// 調(diào)用這個方法renderCustomer(cart, new CoolRenderer(), null);

另外，更喜歡（依靠NullPointerException）：

public void renderCustomer(Cart cart, Renderer renderer, String name) { Objects.requireNonNull(cart, 'Cart 不能為空'); Objects.requireNonNull(renderer, 'Renderer 不能為空'); String customerName = Objects.requireNonNullElseGet(name, () -> 'anonymous'); ...}// 調(diào)用這個方法renderCustomer(cart, new CoolRenderer(), null);

另外，更喜歡（避免NullPointerException和使用IllegalArgumentException或其他異常）：

public final class MyObjects { private MyObjects() { throw new AssertionError('Cannot create instances for you!'); } public static <T, X extends Throwable> T requireNotNullOrElseThrow(T obj, Supplier<? extends X> exceptionSupplier) throws X { if (obj != null) { return obj; } else { throw exceptionSupplier.get(); } }}public void renderCustomer(Cart cart, Renderer renderer, String name) { MyObjects.requireNotNullOrElseThrow(cart,() -> new IllegalArgumentException('Cart cannot be null')); MyObjects.requireNotNullOrElseThrow(renderer,() -> new IllegalArgumentException('Renderer cannot be null')); String customerName = Objects.requireNonNullElseGet(name, () -> 'anonymous'); ...}// 調(diào)用這個方法renderCustomer(cart, new CoolRenderer(), null)第17項：不要使用Optional 的返回空的集合或數(shù)組

支持返回一個空的集合/數(shù)組。考慮到這一點，依靠 Collections.emptyList()， emptyMap()和emptySet()。

為了保持代碼的清潔，輕便避免返回Optional的null或空的集合/數(shù)組。最好返回一個空數(shù)組或集合。

避免：

public Optional<List<String>> fetchCartItems(long id) { Cart cart = ... ; List<String> items = cart.getItems(); //這個可能會返回null return Optional.ofNullable(items);}

首選：

public List<String> fetchCartItems(long id) { Cart cart = ... ; List<String> items = cart.getItems(); // 這個可能會返回null return items == null ? Collections.emptyList() : items;}第18項：避免在集合中使用Optional

見示例

避免：

Map<String, Optional<String>> items = new HashMap<>();items.put('I1', Optional.ofNullable(...));items.put('I2', Optional.ofNullable(...));...Optional<String> item = items.get('I1');if (item == null) { System.out.println('找不到這把鑰匙');} else { String unwrappedItem = item.orElse('NOT FOUND'); System.out.println('Key found, Item: ' + unwrappedItem);}

首選（Java 8）：

Map<String, String> items = new HashMap<>();items.put('I1', 'Shoes');items.put('I2', null);...// get an itemString item = get(items, 'I1'); // ShoesString item = get(items, 'I2'); // nullString item = get(items, 'I3'); // NOT FOUNDprivate static String get(Map<String, String> map, String key) { return map.getOrDefault(key, 'NOT FOUND');}

還可以依賴其他方法，例如：

containsKey()方法 通過擴展實現(xiàn)簡單HashMap Java 8 computeIfAbsent()方法 Apache CommonsDefaultedMap

通過將此示例外推到其他集合，我們可以得出結(jié)論，總有比Optional在集合中使用更好的解決方案。

而且，甚至更糟：

Map<Optional<String>, String> items = new HashMap<>();Map<Optional<String>, Optional<String>> items = new HashMap<>();第19項：不要混淆Optional.of（）和Optional.ofNullable（）

混淆或錯誤地使用 Optional.of而不是Optional.ofNullable，反之亦然，可能會導(dǎo)致令人不快的問題。作為此處的關(guān)鍵，請記住Optional.of(null)會拋出NullPointerException，而Optional.ofNullable(null)會導(dǎo)致 Optional.empty。

使用Optional.of代替Optional.ofNullable示例

避免：

// AVOIDpublic Optional<String> fetchItemName(long id) { String itemName = ... ; // 這可能導(dǎo)致null ... return Optional.of(itemName); // 如果“itemName”為空，則拋出NPE :(}

首選：

public Optional<String> fetchItemName(long id) { String itemName = ... ; // 這可能導(dǎo)致null ... return Optional.ofNullable(itemName); // 沒有NPE風(fēng)險 }

使用Optional.ofNullable代替Optional.of示例

避免：

return Optional.ofNullable('PENDING'); // ofNullable不會增加任何值

首選：

return Optional.of('PENDING'); // 沒有 NPE 風(fēng)險第20項：避免使用可選的<T>，并選擇非通用的OptionalInt，OptionalLong或OptionalDouble

除非你有盒裝原語，避免特定需求 Optional&lt; T &gt; ，并選擇非通用 OptionalInt， OptionalLong或OptionalDouble。

裝箱和拆箱是昂貴的操作，容易導(dǎo)致性能下降。為了消除這種風(fēng)險，我們可以依靠 OptionalInt，OptionalLong 和OptionalDouble。這些是基本類型的包裝int，long,和double。

避免使用（僅在需要裝箱的原語時使用）：

Optional<Integer> price = Optional.of(50);Optional<Long> price = Optional.of(50L);Optional<Double> price = Optional.of(50.43d);

首選：

OptionalInt price = OptionalInt.of(50); // 打開通過 getAsInt()OptionalLong price = OptionalLong.of(50L); // 打開通過 getAsLong()OptionalDouble price = OptionalDouble.of(50.43d); // 打開通過 getAsDouble()第21項：無需包裝主張平等的任擇方案

有兩個Optionals在assertEquals()不需要解開值。這是適用的，因為Optional#equals()比較包裝的值，而不是Optional對象。

Optional.equals()源代碼：

@Overridepublic boolean equals(Object obj) { if (this == obj) { return true; } if (!(obj instanceof Optional)) { return false; } Optional<?> other = (Optional<?>) obj; return Objects.equals(value, other.value);}

避免：

Optional<String> actualItem = Optional.of('Shoes');Optional<String> expectedItem = Optional.of('Shoes'); assertEquals(expectedItem.get(), actualItem.get());

首選：

Optional<String> actualItem = Optional.of('Shoes');Optional<String> expectedItem = Optional.of('Shoes'); assertEquals(expectedItem, actualItem);第22項：通過Map（）和flatMap（）轉(zhuǎn)換值

的Optional.map()和Optional.flatMap()是用于將非常方便的辦法Optional值。該map()方法將函數(shù)參數(shù)應(yīng)用于值，然后返回包裝在中的結(jié)果 Optional，而通過比較，該flatMap()方法采用應(yīng)用于值的函數(shù)參數(shù)，Optional然后直接返回結(jié)果。

使用 map()例子1

避免：

Optional<String> lowername ...; // 可能是空的// transform name to upper caseOptional<String> uppername;if (lowername.isPresent()) { uppername = Optional.of(lowername.get().toUpperCase());} else { uppername = Optional.empty();}

首選：

Optional<String> lowername ...; // 可能是空的// 將名稱轉(zhuǎn)換為大寫Optional<String> uppername = lowername.map(String::toUpperCase);

例子2

避免：

List<Product> products = ... ;Optional<Product> product = products.stream() .filter(p -> p.getPrice() < 50) .findFirst();String name;if (product.isPresent()) { name = product.get().getName().toUpperCase();} else { name = 'NOT FOUND';}//getName()返回一個非空字符串public String getName() { return name;}

首選：

List<Product> products = ... ;String name = products.stream() .filter(p -> p.getPrice() < 50) .findFirst() .map(Product::getName) .map(String::toUpperCase) .orElse('NOT FOUND');// getName()返回一個字符串public String getName() { return name;}

使用 flatMap()

避免：

List<Product> products = ... ;Optional<Product> product = products.stream() .filter(p -> p.getPrice() < 50) .findFirst();String name = null;if (product.isPresent()) { name = product.get().getName().orElse('NOT FOUND').toUpperCase();}// getName() return Optionalpublic Optional<String> getName() { return Optional.ofNullable(name);}

首選：

List<Product> products = ... ;String name = products.stream() .filter(p -> p.getPrice() < 50) .findFirst() .flatMap(Product::getName) .map(String::toUpperCase) .orElse('NOT FOUND');// getName() return Optionalpublic Optional<String> getName() { return Optional.ofNullable(name);}第23項：使用filter（）根據(jù)預(yù)定義的規(guī)則拒絕包裝值

傳遞謂詞（條件）作為參數(shù)并獲取一個 Optional 對象。Optional 如果滿足條件，則使用首字母縮寫；如果不滿足條件，則使用空白 字母 Optional 。使用filter()接受或拒絕包裝的值是一種非常方便的方法，因為無需顯式包裝值就可以實現(xiàn)它。

避免：

public boolean validatePasswordLength(User userId) { Optional<String> password = ...; // User password if (password.isPresent()) { return password.get().length() > 5; } return false;}

首選：

public boolean validatePasswordLength(User userId) { Optional<String> password = ...; // User password return password.filter((p) -> p.length() > 5).isPresent();}第24項：我們是否需要將可選API與流API鏈接在一起？

如果是這樣，則我們使用該 Optional.stream() 方法。從Java 9開始，我們可以通過應(yīng)用方法將Optional實例視為。當(dāng)您需要將Optional API與Stream API鏈接在一起時，這很有用。此方法創(chuàng)建一個元素或一個空元素（如果不存在）。此外，我們可以使用Stream API中可用的所有方法。 Stream``Optional.stream()``Stream``Stream``Optional

避免：

public List<Product> getProductList(List<String> productId) { return productId.stream() .map(this::fetchProductById) .filter(Optional::isPresent) .map(Optional::get) .collect(toList());}public Optional<Product> fetchProductById(String id) { return Optional.ofNullable(...);}

首選：

public List<Product> getProductList(List<String> productId) { return productId.stream() .map(this::fetchProductById) .flatMap(Optional::stream) .collect(toList());}public Optional<Product> fetchProductById(String id) { return Optional.ofNullable(...);}

實際上，Optional.stream()讓我們來代替filter()和 map()用 flatMap()。

另外，我們可以轉(zhuǎn)換Optional為List：

public static <T> List<T> convertOptionalToList(Optional<T> optional) { return optional.stream().collect(toList());}第25項：避免對可選選項使用身份敏感的操作

這包括引用相等（==），基于身份哈希或同步。Optional類是一個基于價值的類作為 LocalDateTime。

避免：

Product product = new Product();Optional<Product> op1 = Optional.of(product);Optional<Product> op2 = Optional.of(product);// op1 == op2 => false, expected trueif (op1 == op2) { ...

首選：

Product product = new Product();Optional<Product> op1 = Optional.of(product);Optional<Product> op2 = Optional.of(product);// op1.equals(op2) => true,expected trueif (op1.equals(op2)) { ...第26項：如果Optional為空，則返回一個布爾值。首選Java 11，Optional.isEmpty（）

從Java 11開始，true如果方法Optional為，則可以很容易地返回a isEmpty()。

避免使用（Java 11+）：

// (Java 11+)public Optional<String> fetchCartItems(long id) { Cart cart = ... ; // this may be null ... return Optional.ofNullable(cart);}public boolean cartIsEmpty(long id) { Optional<String> cart = fetchCartItems(id); return !cart.isPresent();

首選（Java 11+）：

// (Java 11public Optional<String> fetchCartItems(long id) { Cart cart = ... ; // this may be null ... return Optional.ofNullable(cart);}public boolean cartIsEmpty(long id) { Optional<String> cart = fetchCartItems(id); return cart.isEmpty();}

這就是總結(jié)的這26個例子，希望可以避免這些陷阱，永遠(yuǎn)不會出現(xiàn)：java.lang.NullPointerException

到此這篇關(guān)于Java Optional解決空指針異常總結(jié)(java 8 功能)的文章就介紹到這了,更多相關(guān)Java Optional空指針異常內(nèi)容請搜索好吧啦網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持好吧啦網(wǎng)！