App下載

Java8新特性O(shè)ptional類介紹及詳細(xì)的使用方法

猿友 2021-08-04 13:54:09 瀏覽數(shù) (2687)
反饋

Optional的使用詳解

1、Optional介紹

  •  Optional 類是一個可以為null的容器對象。如果值存在則isPresent()方法會返回true,調(diào)用get()方法會返回該對象。
  • Optional 是個容器:它可以保存類型T的值,或者僅僅保存null。Optional提供很多有用的方法,這樣我們就不用顯式進(jìn)行空值檢測。
  • Optional 類的引入很好的解決空指針異常。

2、構(gòu)建Optional

構(gòu)建一個Optional對象;方法有:empty( )、of( )、ofNullable( )

 //返回一個描述給定值的Optional ,如果不為null ,則返回一個空的Optional 。
        //參數(shù):值–描述的可能為null值
        //類型參數(shù):<T> –值的類型
        //返回值:一個Optional與如果指定值是非當(dāng)前值null ,否則一個空Optional
        Optional.ofNullable("");

        //返回一個Optional描述給定的非null值。
        //參數(shù):value –要描述的值,必須為非null
        //類型參數(shù):<T> –值的類型
        //返回值:存在值的Optional
        Optional.of("");

        //返回一個空的Optional實(shí)例。 此Optional沒有值。
        //類型參數(shù):<T> –不存在的值的類型
        //返回值:一個空的Optional
        //api注意:盡管這樣做可能很誘人,但應(yīng)通過將==與Optional.empty()返回的實(shí)例進(jìn)行比較來避免測試對象是否為空。
        // 不能保證它是一個單例。
        // 而是使用isPresent()
        Optional.empty();

3、Optional API 及源碼注解

2021041415173755

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() (如果不存在值,則返回默認(rèn)值)和ifPresent() (如果存在值,則執(zhí)行操作)。
這是一個基于值的類; 在Optional實(shí)例上使用標(biāo)識敏感的操作(包括引用等于( == ),標(biāo)識哈希碼或同步)可能會產(chǎn)生不可預(yù)測的結(jié)果,應(yīng)避免使用
 */
public final class Optional<T> {
    /**
     * empty()通用實(shí)例
     */
    private static final Optional<?> EMPTY = new Optional<>();

    /**
     * 如果不為空,則為該值;否則為false。 如果為null,則表示不存在任何值
     */
    private final T value;

    /**
        構(gòu)造一個空實(shí)例。
        impl注意:
        通常,每個VM僅應(yīng)存在一個空實(shí)例EMPTY 
     */
    private Optional() {
        this.value = null;
    }

    /**
        返回一個空的Optional實(shí)例。 此Optional沒有值。
        類型參數(shù):<T> –不存在的值的類型
        返回值:一個空的Optional
        api注意:
        盡管這樣做可能很誘人,但應(yīng)通過將==與Optional.empty()返回的實(shí)例進(jìn)行比較來避免測試對象是否為空。 不能保證它是一個單例。 而是使用isPresent() 
     */
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

    /**
        使用描述的值構(gòu)造一個實(shí)例。
        參數(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與如果指定值是非當(dāng)前值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ù):謂詞–應(yīng)用于值的謂詞(如果存在)
        返回值:一個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ù)應(yīng)用于該值的結(jié)果,否則返回一個空的Optional 。
        如果映射函數(shù)返回null結(jié)果,則此方法返回空的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ù)應(yīng)用于該值的結(jié)果,否則返回一個空的Optional 。
        此方法類似于map(Function) ,但是映射函數(shù)是其結(jié)果已經(jīng)是Optional函數(shù),如果調(diào)用該函數(shù),則flatMap不會將其包裝在其他Optional 。

        參數(shù):mapper –應(yīng)用于值的映射函數(shù)(如果存在)
        類型參數(shù):<U> –映射函數(shù)返回的Optional值的類型
        返回值:施加的結(jié)果Optional荷瘤映射函數(shù)此的值Optional ,如果一個值存在,否則一個空Optional
        拋出:NullPointerException如果映射函數(shù)為null或返回null結(jié)果

     */
    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產(chǎn)生通過供給功能。

        參數(shù):供應(yīng)商–產(chǎn)生要返回的Optional的供應(yīng)功能
        返回值:返回一個Optional描述此的值Optional ,如果一個值存在,否則Optional所生產(chǎn)的供應(yīng)功能。
        拋出:NullPointerException如果提供的函數(shù)為null或產(chǎn)生null結(jié)果
     * @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;
    }

    /**
        如果存在值,則返回該值,否則返回由供應(yīng)函數(shù)產(chǎn)生的結(jié)果。

        參數(shù):供應(yīng)商–產(chǎn)生要返回的值的供應(yīng)函數(shù)
        返回值:值(如果存在),否則提供功能產(chǎn)生的結(jié)果
     */
    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ù)產(chǎn)生的異常。

        參數(shù):exceptionSupplier –產(chǎn)生要拋出的異常的提供函數(shù)
        類型參數(shù):<X> –引發(fā)的異常類型
        返回值:值(如果存在)
        拋出:X –如果不存在任何值NullPointerException如果不存在任何值并且異常提供函數(shù)為null
        api注意:帶有空參數(shù)列表的對異常構(gòu)造函數(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、構(gòu)建

//返回一個描述給定值的Optional ,如果不為null ,則返回一個空的Optional 。
//參數(shù):值–描述的可能為null值
//類型參數(shù):<T> –值的類型
//返回值:一個Optional與如果指定值是非當(dāng)前值null ,否則一個空Optional
Optional s1 = Optional.ofNullable(null);

// 構(gòu)建一個value不可以為null的optional對象,如果of()的入?yún)閚ull會報空指針異常;
Optional<MyUser> s2 = Optional.of(new MyUser("阿輝2","123456"));

// 構(gòu)建一個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;我們在調(diào)用get之前,一定要先調(diào)用isPresent,因?yàn)橹苯尤绻鹶alue是null,直接調(diào)用get會報異常;
        if (myUser1.isPresent()) {
            MyUser value = myUser1.get();
            System.out.println("optional value:" + value);
        } else {
            System.out.println("optional value==null");
        }
        // ifPresent傳入一段lambda,當(dāng)value!=null時,執(zhí)行里面的邏輯;當(dāng)當(dāng)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.empty

4.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類型的對象作為默認(rèn)值;
        //    當(dāng)value!=null時,返回value值;當(dāng)value==null時,返回默認(rèn)值作為代替;
        MyUser userInfo2 = userInfoEmptyOpt.orElse(new MyUser("阿飛1","123456"));
        
        // 3、orElseGet和orElse不同的是orElseGet可以傳入一段lambda表達(dá)式;
        // 當(dāng)value!=null時,返回value值;
        // 當(dāng)value==null時,使用該lambda返回的對象作為默認(rèn)值;
        MyUser userInfo3 = userInfoEmptyOpt.orElseGet(() -> new MyUser("阿飛2","123456"));
        
        // 4、orElseThrow可以傳入一段lambda表達(dá)式,lambda返回一個Exception;當(dāng)value!=null時,返回value值;當(dāng)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、轉(zhuǎn)換類

 Optional<MyUser> userInfoOpt = Optional.of(new MyUser("阿飛","123456"));

        // 原來value的類型是UserInfo,經(jīng)過map轉(zhuǎn)換為Optional<String>
        Optional<String> username = userInfoOpt.map(MyUser::getId);

        // 當(dāng)map的入?yún)⒁彩且粋€Optional時,經(jīng)過map轉(zhuǎn)化后會形成Optional<Optional<String>>這種嵌套結(jié)構(gòu);但flatMap可以把這種嵌套結(jié)構(gòu)打平;
        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();
    }
}

平時:

項目里的實(shí)例:

return Optional.ofNullable(iNewsMapper.selectNewsWithNewsCategoryById(id))
        .orElseThrow(() -> new BaseException(DataSourceResponseEnum.SELECT_ERROR));

ofNullable:

返回一個描述給定值的Optional ,如果不為null ,則返回一個空的Optional 。

orElseThrow

如果存在值,則返回該值,否則拋出由異常提供函數(shù)產(chǎn)生的異常。

以前的寫法是:

if(iNewsMapper.selectNewsWithNewsCategoryById(id)==null){
    throw new BaseException(DataSourceResponseEnum.SELECT_ERROR);
}
else{
    return iNewsMapper.selectNewsWithNewsCategoryById(id);
}

這種寫法是比較丑陋的,為了避免上述丑陋的寫法,讓丑陋的設(shè)計變得優(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)雅些,但是缺點(diǎn)也很明顯,邏輯性沒那么明顯了。

到此這篇關(guān)于Java8新特性之Optional的詳細(xì)解析的文章就介紹到這了,更多相關(guān)Java中optional類詳解內(nèi)容請搜索W3Cschool以前的文章或繼續(xù)瀏覽下面的相關(guān)文章,希望大家以后多多支持!


0 人點(diǎn)贊