1、概述

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

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

2、 目 錄

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

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

[第3項：當不存在任何值時，通過Optional.orElse（）方法設置/返回已經構造的默認對象]

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

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

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

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

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

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

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

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

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

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

[第14項：在構造函數參數中不要使用可選]

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

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

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

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

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

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

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

[第22項：通過Map（）和flatMap（）轉換值]

[第23項：使用filter（）根據預定義的規則拒絕包裝值]

[第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項：調用Optional.get（）之前，確保Optional具有值

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

避免：

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

首選：

// 首選if (cart.isPresent()) { Cart myCart = cart.get(); ...} else { ... // 做一些不調用carter .get()的事情}第3項：當不存在任何值時，通過Optional.orElse（）方法設置/返回已經構造的默認對象

使用Optional.orElse()方法代表了用于設置/返回值的isPresent()-get()對的優雅替代。這里重要的一點是，即使是非空可選的，也要計算oforElse()參數。這意味著即使不使用它，也會對它進行評估，這是一種性能損失。在這個上下文中，useorElse()只在參數(默認對象)已經構造完成時才使用。在其他情況下，請依賴第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（）方法設置/返回不存在的默認對象

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

避免：

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

另外，請避免：

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

首選：

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

使用該Optional.orElseThrow()方法代表了該方法的另一種優雅替代方法isPresent()-get()。有時，當Optional不存在值時，你要做的就是拋出java.util.NoSuchElementException異常。從Java 10開始，這可以通過orElseThrow()不帶參數的方法來完成。對于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項：當不存在任何值時，通過orElseThrow（Supplier <？extended X> exceptionSupplier）引發顯式異常

在Java 10中，對于 java.util.NoSuchElementException，請使用 orElseThrow()，如第5項所示。使用該Optional.orElseThrow(Supplier&lt;? extends X&gt; exceptionSupplier)方法代表了該方法的另一種優雅替代方法isPresent()-get()。有時，當Optional不存在值時，你要做的就是拋出一個明確的異常。從Java 10開始，如果該異常java.util.NoSuchElementException僅依賴于orElseThrow()不帶參數的方法-第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項：當您有可選的并且需要空引用時，請使用orElse（null）

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

避免：

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

首選：

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

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

避免：

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

首選：

Optional<String> status ... ;...status.ifPresent(System.out::println);第9項：使用可選（如果存在）。如果不存在，請執行基于空的操作。這是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項：當值存在時，設置/返回該可選項。如果不存在任何值，則設置/返回另一個可選項。這是Java 9的Optional.or（）的工作。

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

避免：

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語句污染代碼，并考慮繼續使用鏈。在這種情況下，orElse()and和orElseXXX()非常方便，因為它們可以直接在lambda表達式鏈中鏈接，并避免破壞代碼。

例子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）或構造函數參數中使用。

請記住，這Optional 并不是要用于字段，并且不會實現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項：在構造函數參數中不要使用可選

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

這是違背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現在返回 Optional。不要以這個示例作為轉換所有此類getter的規則。多數情況下，getter返回集合或數組，在這種情況下，他們更喜歡返回空集合/數組而不是 Optional。

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

第15項：在Setters參數中不要使用可選

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

避免：

@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項：在方法參數中不要使用可選

不要 Optional 用作字段或設置器和構造函數的參數。Optional在in方法中使用參數是另一個常見錯誤。這將導致不必要的復雜代碼。負責檢查參數，而不是強制調用站點創建 Optional。這種做法會使代碼混亂，并可能導致依賴性。隨著時間的流逝，您將在所有地方使用它。請記住，這Optional只是另一個對象（容器），而且價它消耗的內存是強引用的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'); ...}//調用這個是錯誤的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'); ...}// 調用這個方法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'); ...}// 調用這個方法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'); ...}// 調用這個方法renderCustomer(cart, new CoolRenderer(), null)第17項：不要使用Optional 的返回空的集合或數組

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

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

避免：

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()方法 通過擴展實現簡單HashMap Java 8 computeIfAbsent()方法 Apache CommonsDefaultedMap

通過將此示例外推到其他集合，我們可以得出結論，總有比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，反之亦然，可能會導致令人不快的問題。作為此處的關鍵，請記住Optional.of(null)會拋出NullPointerException，而Optional.ofNullable(null)會導致 Optional.empty。

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

避免：

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

首選：

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

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

避免：

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

首選：

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

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

裝箱和拆箱是昂貴的操作，容易導致性能下降。為了消除這種風險，我們可以依靠 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（）轉換值

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

使用 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 ...; // 可能是空的// 將名稱轉換為大寫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（）根據預定義的規則拒絕包裝值

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

避免：

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開始，我們可以通過應用方法將Optional實例視為。當您需要將Optional API與Stream API鏈接在一起時，這很有用。此方法創建一個元素或一個空元素（如果不存在）。此外，我們可以使用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()。

另外，我們可以轉換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();}

這就是總結的這26個例子，希望可以避免這些陷阱，永遠不會出現：java.lang.NullPointerException

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