java中Optional的使用詳細解析
構建一個Optional對象；方法有：empty( )、of( )、ofNullable( )
//返回一個描述給定值的Optional ，如果不為null ，則返回一個空的Optional 。//參數(shù)：值?描述的可能為null值//類型參數(shù)：<T> ?值的類型//返回值：一個Optional與如果指定值是非當前值null ，否則一個空OptionalOptional.ofNullable('');//返回一個Optional描述給定的非null值。//參數(shù)：value ?要描述的值，必須為非null//類型參數(shù)：<T> ?值的類型//返回值：存在值的OptionalOptional.of('');//返回一個空的Optional實例。 此Optional沒有值。//類型參數(shù)：<T> ?不存在的值的類型//返回值：一個空的Optional//api注意：盡管這樣做可能很誘人，但應通過將==與Optional.empty()返回的實例進行比較來避免測試對象是否為空。// 不能保證它是一個單例。// 而是使用isPresent()Optional.empty();3、Optional API 及源碼注解
package java.util;import java.util.function.Consumer;import java.util.function.Function;import java.util.function.Predicate;import java.util.function.Supplier;import java.util.stream.Stream;/**一個可能包含也可能不包含非null值的容器對象。 如果存在值，則isPresent()返回true 。 如果不存在任何值，則該對象被視為空，并且isPresent()返回false 。提供了其他取決于所包含值是否存在的方法，例如orElse() （如果不存在值，則返回默認值）和ifPresent() （如果存在值，則執(zhí)行操作）。這是一個基于值的類； 在Optional實例上使用標識敏感的操作（包括引用等于（ == ），標識哈希碼或同步）可能會產生不可預測的結果，應避免使用 */public final class Optional<T> { /** * empty()通用實例 */ private static final Optional<?> EMPTY = new Optional<>(); /** * 如果不為空，則為該值；否則為false。 如果為null，則表示不存在任何值 */ private final T value; /**構造一個空實例。impl注意：通常，每個VM僅應存在一個空實例EMPTY */ private Optional() {this.value = null; } /**返回一個空的Optional實例。 此Optional沒有值。類型參數(shù)：<T> ?不存在的值的類型返回值：一個空的Optionalapi注意：盡管這樣做可能很誘人，但應通過將==與Optional.empty()返回的實例進行比較來避免測試對象是否為空。 不能保證它是一個單例。 而是使用isPresent() */ public static<T> Optional<T> empty() {@SuppressWarnings('unchecked')Optional<T> t = (Optional<T>) EMPTY;return t; } /**使用描述的值構造一個實例。參數(shù)：值?要描述的非null值拋出：NullPointerException如果值為null */ private Optional(T value) {this.value = Objects.requireNonNull(value); } /**返回一個Optional描述給定的非null值。參數(shù)：value ?要描述的值，必須為非null類型參數(shù)：<T> ?值的類型返回值：存在值的Optiona */ public static <T> Optional<T> of(T value) {return new Optional<>(value); } /**返回一個描述給定值的Optional ，如果不為null ，則返回一個空的Optional 。參數(shù)：值?描述的可能為null值類型參數(shù)：<T> ?值的類型返回值：一個Optional與如果指定值是非當前值null ，否則一個空Optional */ public static <T> Optional<T> ofNullable(T value) {return value == null ? empty() : of(value); } /**如果存在值，則返回該值，否則拋出NoSuchElementException 。返回值：此Optional描述的非null值拋出：NoSuchElementException如果不存在任何值api注意：此方法的首選替代方法是orElseThrow() 。 */ public T get() {if (value == null) { throw new NoSuchElementException('No value present');}return value; } /**如果存在值，則返回true ，否則返回false 。返回值：如果存在值，則為true ，否則為false */ public boolean isPresent() {return value != null; } /**如果不存在值，則返回true ，否則返回false 。返回值：如果不存在值，則為true ，否則為false */ public boolean isEmpty() {return value == null; } /**如果存在值，則使用該值執(zhí)行給定的操作，否則不執(zhí)行任何操作。參數(shù)：動作?要執(zhí)行的動作（如果存在值） */ public void ifPresent(Consumer<? super T> action) {if (value != null) { action.accept(value);} } /**如果存在值，則使用該值執(zhí)行給定的操作，否則執(zhí)行給定的基于空的操作。參數(shù)：動作?要執(zhí)行的動作（如果存在值）emptyAction ?要執(zhí)行的基于空的操作（如果不存在任何值）拋出：NullPointerException如果存在一個值并且給定的操作為null ，或者不存在任何值并且給定的基于空的操作為null @since 9 */ public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {if (value != null) { action.accept(value);} else { emptyAction.run();} } /**如果存在一個值，并且該值與給定的謂詞匹配，則返回描述該值的Optional ，否則返回一個空的Optional 。參數(shù)：謂詞?應用于值的謂詞（如果存在）返回值：一個Optional描述此的值Optional ，如果一個值存在并且該值給定的謂詞相匹配，否則一個空Optional拋出：NullPointerException如果謂詞為null */ public Optional<T> filter(Predicate<? super T> predicate) {Objects.requireNonNull(predicate);if (!isPresent()) { return this;} else { return predicate.test(value) ? this : empty();} } /**如果存在值，則返回一個Optional描述（就像by ofNullable ），將給定映射函數(shù)應用于該值的結果，否則返回一個空的Optional 。如果映射函數(shù)返回null結果，則此方法返回空的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));} } /** 如果存在一個值，則返回將給定Optional -bearing映射函數(shù)應用于該值的結果，否則返回一個空的Optional 。此方法類似于map(Function) ，但是映射函數(shù)是其結果已經是Optional函數(shù)，如果調用該函數(shù)，則flatMap不會將其包裝在其他Optional 。參數(shù)：mapper ?應用于值的映射函數(shù)（如果存在）類型參數(shù)：<U> ?映射函數(shù)返回的Optional值的類型返回值：施加的結果Optional荷瘤映射函數(shù)此的值Optional ，如果一個值存在，否則一個空Optional拋出：NullPointerException如果映射函數(shù)為null或返回null結果 */ public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {Objects.requireNonNull(mapper);if (!isPresent()) { return empty();} else { @SuppressWarnings('unchecked') Optional<U> r = (Optional<U>) mapper.apply(value); return Objects.requireNonNull(r);} } /**如果值存在時，返回一個Optional描述的值，否則將返回一個Optional產生通過供給功能。參數(shù)：供應商?產生要返回的Optional的供應功能返回值：返回一個Optional描述此的值Optional ，如果一個值存在，否則Optional所生產的供應功能。拋出：NullPointerException如果提供的函數(shù)為null或產生null結果 * @since 9 */ public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {Objects.requireNonNull(supplier);if (isPresent()) { return this;} else { @SuppressWarnings('unchecked') Optional<T> r = (Optional<T>) supplier.get(); return Objects.requireNonNull(r);} } /**如果存在值，則返回僅包含該值的順序Stream ，否則返回空Stream 。返回值：作為Stream的可選值 * @since 9 */ public Stream<T> stream() {if (!isPresent()) { return Stream.empty();} else { return Stream.of(value);} } /**如果存在值，則返回該值，否則返回other 。參數(shù)：其他?要返回的值（如果不存在任何值）。 可以為null 。返回值：值（如果存在），否則other */ public T orElse(T other) {return value != null ? value : other; } /**如果存在值，則返回該值，否則返回由供應函數(shù)產生的結果。參數(shù)：供應商?產生要返回的值的供應函數(shù)返回值：值（如果存在），否則提供功能產生的結果 */ public T orElseGet(Supplier<? extends T> supplier) {return value != null ? value : supplier.get(); } /** * If a value is present, returns the value, otherwise throws * {@code NoSuchElementException}. * * @return the non-{@code null} value described by this {@code Optional} * @throws NoSuchElementException if no value is present * @since 10 */ public T orElseThrow() {if (value == null) { throw new NoSuchElementException('No value present');}return value; } /**如果存在值，則返回該值，否則拋出由異常提供函數(shù)產生的異常。參數(shù)：exceptionSupplier ?產生要拋出的異常的提供函數(shù)類型參數(shù)：<X> ?引發(fā)的異常類型返回值：值（如果存在）拋出：X ?如果不存在任何值NullPointerException如果不存在任何值并且異常提供函數(shù)為nullapi注意：帶有空參數(shù)列表的對異常構造函數(shù)的方法引用可用作提供者 */ public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {if (value != null) { return value;} else { throw exceptionSupplier.get();} }}4、測試使用4.1、構建
//返回一個描述給定值的Optional ，如果不為null ，則返回一個空的Optional 。//參數(shù)：值?描述的可能為null值//類型參數(shù)：<T> ?值的類型//返回值：一個Optional與如果指定值是非當前值null ，否則一個空OptionalOptional s1 = Optional.ofNullable(null);// 構建一個value不可以為null的optional對象，如果of()的入?yún)閚ull會報空指針異常；Optional<MyUser> s2 = Optional.of(new MyUser('阿輝2','123456'));// 構建一個value可以為null的optional對象；Optional<MyUser> s3 = Optional.ofNullable(null);System.out.println(s1);System.out.println(s2);System.out.println(s3);/* 輸出 * Optional.empty * Optional[MyUser{id=’阿輝2’, username=’123456’}] * Optional.empty **/4.2、判斷類
Optional<MyUser> myUser1 = Optional.empty();Optional<MyUser> myUser2 = Optional.of(new MyUser('阿飛', '123456'));// filter傳入一個lambda，lambda返回值為boolean；true:不做任何改變，false:返回一個空的optional；Optional<MyUser> myUser3 = myUser2.filter(user -> '錯誤的密碼'.equals(user.getUsername()));// isPresent就是判斷value是不是null；我們在調用get之前，一定要先調用isPresent，因為直接如果value是null，直接調用get會報異常；if (myUser1.isPresent()) { MyUser value = myUser1.get(); System.out.println('optional value:' + value);} else { System.out.println('optional value==null');}// ifPresent傳入一段lambda，當value!=null時，執(zhí)行里面的邏輯；當當value==null時，啥都不干；myUser2.ifPresent(value -> System.out.println('optional value:' + value));System.out.println(myUser3);// 輸入如下：//optional value==null//optional value:MyUser{id=’阿飛’, username=’123456’}//Optional.empty4.3、獲取類（常用）
Optional<MyUser> userInfoEmptyOpt = Optional.empty();Optional<MyUser> userInfoOpt = Optional.of(new MyUser('阿飛','123456'));// 1、直接獲取，注意如果value==null，會報NoSuchElementException異常MyUser userInfo1 = userInfoOpt.get();// 2、orElse可以傳入一個UserInfo類型的對象作為默認值;// 當value!=null時，返回value值；當value==null時，返回默認值作為代替；MyUser userInfo2 = userInfoEmptyOpt.orElse(new MyUser('阿飛1','123456'));// 3、orElseGet和orElse不同的是orElseGet可以傳入一段lambda表達式；// 當value!=null時，返回value值；// 當value==null時，使用該lambda返回的對象作為默認值；MyUser userInfo3 = userInfoEmptyOpt.orElseGet(() -> new MyUser('阿飛2','123456'));// 4、orElseThrow可以傳入一段lambda表達式，lambda返回一個Exception；當value!=null時，返回value值；當value==null時，拋出該異常；MyUser userInfo4 = userInfoOpt.orElseThrow(NullPointerException::new);System.out.println(userInfo1);System.out.println(userInfo2);System.out.println(userInfo3);System.out.println(userInfo4);// 輸出如下：// UserInfo(username=阿飛, password=123456)// UserInfo(username=阿飛1, password=123456)// UserInfo(username=阿飛2, password=123456)// UserInfo(username=阿飛, password=123456)4.4、轉換類
Optional<MyUser> userInfoOpt = Optional.of(new MyUser('阿飛','123456'));// 原來value的類型是UserInfo，經過map轉換為Optional<String>Optional<String> username = userInfoOpt.map(MyUser::getId);// 當map的入?yún)⒁彩且粋€Optional時，經過map轉化后會形成Optional<Optional<String>>這種嵌套結構；但flatMap可以把這種嵌套結構打平；Optional<Optional<String>> unFlatMap = userInfoOpt.map(user -> Optional.of(user.getId()));Optional<String> flatMap = userInfoOpt.flatMap(user -> Optional.of(user.getId()));System.out.println(username);System.out.println(unFlatMap);System.out.println(flatMap);// 輸出如下：// Optional[阿飛]// Optional[Optional[阿飛]]// Optional[阿飛]4.5、測試API使用
import lombok.AllArgsConstructor;import lombok.Data;import lombok.NoArgsConstructor;import lombok.ToString;import org.junit.Test;import java.math.BigDecimal;import java.util.Optional;/** * @version 1.0 * @author： crush * @date： 2021-04-12 20:51 */public class OptionalStudy { @Data @NoArgsConstructor @AllArgsConstructor @ToString static class Employee {private Long id;private String name;private Boolean leader; } @Data @NoArgsConstructor @AllArgsConstructor @ToString static class Leader {private Long employeeId;private BigDecimal bonus; } /** * 找到ID為1的員工，如果有獎金就打印出來，沒有就打印沒有獎金； * @throws */ @Test public void tst() {Optional<Leader> leader = Optional.ofNullable(getEmployeeById(1L).filter(Employee::getLeader).map(Employee::getId).flatMap(this::getLeaderByEmployeeId).orElse(null));if (leader.isPresent()) { Optional.of(leader.map(Leader::getBonus).map(bonus -> String.format('員工ID為1的leader獎金為：%s', bonus)).orElse('員工ID為1的leader也沒有獎金')).ifPresent(System.out::println);} else { System.out.println('員工ID為1的leader未找到，他可能只是一個基層員工，不配擁有獎金');} } private Optional<Employee> getEmployeeById(Long id) {//return Optional.of(new Employee(1L, '大老板', Boolean.TRUE));return Optional.of(new Employee(1L, '大老板', Boolean.FALSE)); } private Optional<Leader> getLeaderByEmployeeId(Long employeeId) {//return employeeId == 1L ? Optional.of(new Leader(1L, BigDecimal.valueOf(1000000000))) : Optional.empty();return employeeId == 1L ? Optional.of(new Leader(1L, null)) : Optional.empty(); }}
平時：
項目里的實例：
return Optional.ofNullable(iNewsMapper.selectNewsWithNewsCategoryById(id)).orElseThrow(() -> new BaseException(DataSourceResponseEnum.SELECT_ERROR));
ofNullable:
返回一個描述給定值的Optional ，如果不為null ，則返回一個空的Optional 。
orElseThrow
如果存在值，則返回該值，否則拋出由異常提供函數(shù)產生的異常。
以前的寫法是：
if(iNewsMapper.selectNewsWithNewsCategoryById(id)==null){ throw new BaseException(DataSourceResponseEnum.SELECT_ERROR);}else{ return iNewsMapper.selectNewsWithNewsCategoryById(id);}
這種寫法是比較丑陋的，為了避免上述丑陋的寫法，讓丑陋的設計變得優(yōu)雅。JAVA8提供了Optional類來優(yōu)化這種寫法。
例二：
Optional<News> news = Optional.ofNullable(iNewsMapper.selectNewsWithNewsCategoryById(id));news.ifPresent(item -> { item.setLastId(this.selectLastNewsId(id)); item.setNextId(this.selectNextNewsId(id)); taskExecutor.execute(() -> this.addReadCount(id, ip));});return news.orElseThrow(() -> new BaseException(DataSourceResponseEnum.SELECT_ERROR));
博主自己第一次知道Optional，這次看項目的時候，正好遇上了就去好好的康了一番。
我的建議是：喜歡就用，不喜歡就不用。
用的話看起來是會顯的更為優(yōu)雅些，但是缺點也很明顯，邏輯性沒那么明顯了。
到此這篇關于java新特性之Optional的詳細解析的文章就介紹到這了,更多相關java中optional類詳解內容請搜索好吧啦網以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持好吧啦網！
相關文章：
網公網安備