Java8中Optional的使用方法詳解

更新時(shí)間：2024年01月19日 09:45:55 作者：CUIYD_1989

這篇文章主要介紹了Java8中Optional的使用方法詳解,傳統(tǒng)的寫(xiě)代碼方式經(jīng)常會(huì)遇到NullPointerException,這就需要我們?cè)诖a中經(jīng)常判空,而判空的寫(xiě)法又會(huì)顯得很累贅,這里就可以用到Optional來(lái)簡(jiǎn)化代碼,需要的朋友可以參考下

1、Optional 介紹

傳統(tǒng)的寫(xiě)代碼方式經(jīng)常會(huì)遇到NullPointerException，這就需要我們?cè)诖a中經(jīng)常判空。而判空的寫(xiě)法又會(huì)顯得很累贅，這里就可以用到Optional來(lái)簡(jiǎn)化代碼。

Optional是在java.util包下的一個(gè)用于代替null的一個(gè)工具類(lèi)。

import java.util.Optional;

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

2、構(gòu)建Optional

構(gòu)建一個(gè)Optional對(duì)象；方法有：empty( )、of( )、ofNullable( )

//返回一個(gè)描述給定值的Optional ，如果不為null ，則返回一個(gè)空的Optional 。
//參數(shù)：值–描述的可能為null值
//類(lèi)型參數(shù)：<T> –值的類(lèi)型
//返回值：一個(gè)Optional與如果指定值是非當(dāng)前值null ，否則一個(gè)空Optional
Optional.ofNullable(T value);//value為null的話(huà)返回-Optional.empty()；
//返回一個(gè)Optional描述給定的非null值。
//參數(shù)：value –要描述的值，必須為非null
//類(lèi)型參數(shù)：<T> –值的類(lèi)型
//返回值：存在值的Optional
Optional.of(T value);//  value需要非 null,null會(huì)拋異常；
//返回一個(gè)空的Optional實(shí)例。 此Optional沒(méi)有值。
//類(lèi)型參數(shù)：<T> –不存在的值的類(lèi)型
//返回值：一個(gè)空的Optional
//api注意：盡管這樣做可能很誘人，但應(yīng)通過(guò)將==與Optional.empty()返回的實(shí)例進(jìn)行比較來(lái)避免測(cè)試對(duì)象是否為空。
// 不能保證它是一個(gè)單例。
// 而是使用isPresent()
Optional.empty();// 用來(lái)構(gòu)造一個(gè)空的 Optional；

3、Optional的相關(guān)方法介紹

isPresent()：持有非空值，返回true；否則false；

  Optional optional = Optional.ofNullable(null);
Optional optional1 = Optional.of("");
Optional optional2 = Optional.empty();
System.out.println(optional.isPresent());
System.out.println(optional1.isPresent());
System.out.println(optional2.isPresent());

打印結(jié)果：

false
true
false

ifPresent()：如果 Optional 中有值，則對(duì)該值調(diào)用consumer.accept，否則什么也不做。
orElse：參數(shù)是一個(gè)值，如果 Optional 中有值則將其返回，否則返回 orElse 方法傳入的參數(shù)。

Optional 中有值：

//Optional 中有值
Optional optional = Optional.ofNullable("fdgshsgf");
System.out.println(optional.orElse("reiwgybv"));

打印結(jié)果：

在這里插入圖片描述

Optional 中沒(méi)有值：

//Optional 中有值
Optional optional = Optional.ofNullable("fdgshsgf");
System.out.println(optional.orElse("reiwgybv"));

打印結(jié)果：

在這里插入圖片描述

注意： Optional 只有null時(shí)表示為空值，其他任何情況都不表示空值，如空字符串。

 Optional optional = Optional.ofNullable("");
 System.out.println(optional.orElse("reiwgybv"));

打印結(jié)果是空字符串：

在這里插入圖片描述

orElseGet：傳入的參數(shù)為一個(gè) Supplier 接口的實(shí)現(xiàn)。
orElseThrow：沒(méi)有值的時(shí)候會(huì)拋出異常，拋出的異常由傳入的 exceptionSupplier 提供。

示例：

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

map：為空返回 Optional.empty；否則返回一個(gè)新的 Optional：函數(shù) mapper 在以 value 作為輸入時(shí)的輸出值；可以多次使用map操作。

Optional<String> username = Optional.ofNullable(getUserById(id))
		.map(user -> user.getUsername())
		.map(name -> name.replace('_', ' '));
System.out.println("Username is: " + username.orElse("Unknown"));

flatMap： map 方法參數(shù)中的函數(shù) mapper 輸出的是值，然后 map 方法會(huì)使用 Optional.ofNullable 將其包裝為 Optional；而 flatMap 要求參數(shù)中的函數(shù) mapper 輸出的就是 Optional。

Optional<String> username = Optional.ofNullable(getUserById(id))
		.flatMap(user -> Optional.of(user.getUsername()))
		.flatMap(name -> Optional.of(name.toLowerCase()));
System.out.println("Username is: " + username.orElse("Unknown"));

filter：接受一個(gè) Predicate 來(lái)對(duì) Optional 中包含的值進(jìn)行過(guò)濾，如果包含的值滿(mǎn)足條件，那么還是返回這個(gè) Optional；否則返回 Optional.empty。

4、源碼解析

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;
/**
一個(gè)可能包含也可能不包含非null值的容器對(duì)象。 如果存在值，則isPresent()返回true 。 如果不存在任何值，則該對(duì)象被視為空，并且isPresent()返回false 。
提供了其他取決于所包含值是否存在的方法，例如orElse() （如果不存在值，則返回默認(rèn)值）和ifPresent() （如果存在值，則執(zhí)行操作）。
這是一個(gè)基于值的類(lèi)； 在Optional實(shí)例上使用標(biāo)識(shí)敏感的操作（包括引用等于（ == ），標(biāo)識(shí)哈希碼或同步）可能會(huì)產(chǎn)生不可預(yù)測(cè)的結(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)造一個(gè)空實(shí)例。
        impl注意：
        通常，每個(gè)VM僅應(yīng)存在一個(gè)空實(shí)例EMPTY 
     */
    private Optional() {
        this.value = null;
    }
    /**
        返回一個(gè)空的Optional實(shí)例。 此Optional沒(méi)有值。
        類(lèi)型參數(shù)：<T> –不存在的值的類(lèi)型
        返回值：一個(gè)空的Optional
        api注意：
        盡管這樣做可能很誘人，但應(yīng)通過(guò)將==與Optional.empty()返回的實(shí)例進(jìn)行比較來(lái)避免測(cè)試對(duì)象是否為空。 不能保證它是一個(gè)單例。 而是使用isPresent() 
     */
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
    /**
        使用描述的值構(gòu)造一個(gè)實(shí)例。
        參數(shù)：值–要描述的非null值
        拋出：NullPointerException如果值為null
     */
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
    /**
        返回一個(gè)Optional描述給定的非null值。
        參數(shù)：value –要描述的值，必須為非null
        類(lèi)型參數(shù)：<T> –值的類(lèi)型
        返回值：存在值的Optiona
     */
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
    /**
        返回一個(gè)描述給定值的Optional ，如果不為null ，則返回一個(gè)空的Optional 。
        參數(shù)：值–描述的可能為null值
        類(lèi)型參數(shù)：<T> –值的類(lèi)型
        返回值：一個(gè)Optional與如果指定值是非當(dāng)前值null ，否則一個(gè)空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ù)：動(dòng)作–要執(zhí)行的動(dòng)作（如果存在值）
     */
    public void ifPresent(Consumer<? super T> action) {
        if (value != null) {
            action.accept(value);
        }
    }
    /**
        如果存在值，則使用該值執(zhí)行給定的操作，否則執(zhí)行給定的基于空的操作。
        參數(shù)：動(dòng)作–要執(zhí)行的動(dòng)作（如果存在值）emptyAction –要執(zhí)行的基于空的操作（如果不存在任何值）
        拋出：NullPointerException如果存在一個(gè)值并且給定的操作為null ，或者不存在任何值并且給定的基于空的操作為null 
     	@since 9
     */
    public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
        if (value != null) {
            action.accept(value);
        } else {
            emptyAction.run();
        }
    }
    /**
        如果存在一個(gè)值，并且該值與給定的謂詞匹配，則返回描述該值的Optional ，否則返回一個(gè)空的Optional 。
        參數(shù)：謂詞–應(yīng)用于值的謂詞（如果存在）
        返回值：一個(gè)Optional描述此的值Optional ，如果一個(gè)值存在并且該值給定的謂詞相匹配，否則一個(gè)空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();
        }
    }
    /**
        如果存在值，則返回一個(gè)Optional描述（就像by ofNullable ），將給定映射函數(shù)應(yīng)用于該值的結(jié)果，否則返回一個(gè)空的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));
        }
    }
    /**
         如果存在一個(gè)值，則返回將給定Optional -bearing映射函數(shù)應(yīng)用于該值的結(jié)果，否則返回一個(gè)空的Optional 。
        此方法類(lèi)似于map(Function) ，但是映射函數(shù)是其結(jié)果已經(jīng)是Optional函數(shù)，如果調(diào)用該函數(shù)，則flatMap不會(huì)將其包裝在其他Optional 。
        參數(shù)：mapper –應(yīng)用于值的映射函數(shù)（如果存在）
        類(lèi)型參數(shù)：<U> –映射函數(shù)返回的Optional值的類(lèi)型
        返回值：施加的結(jié)果Optional荷瘤映射函數(shù)此的值Optional ，如果一個(gè)值存在，否則一個(gè)空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);
        }
    }
    /**
        如果值存在時(shí)，返回一個(gè)Optional描述的值，否則將返回一個(gè)Optional產(chǎn)生通過(guò)供給功能。
        參數(shù)：供應(yīng)商–產(chǎn)生要返回的Optional的供應(yīng)功能
        返回值：返回一個(gè)Optional描述此的值Optional ，如果一個(gè)值存在，否則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ù)
        類(lèi)型參數(shù)：<X> –引發(fā)的異常類(lèi)型
        返回值：值（如果存在）
        拋出：X –如果不存在任何值NullPointerException如果不存在任何值并且異常提供函數(shù)為null
        api注意：帶有空參數(shù)列表的對(duì)異常構(gòu)造函數(shù)的方法引用可用作提供者
     */
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }
}

5、結(jié)合業(yè)務(wù)現(xiàn)實(shí)解析

創(chuàng)建一個(gè)動(dòng)物實(shí)體類(lèi)：

/**
 * 動(dòng)物實(shí)體類(lèi)
 */
 @Data
public class Animal {
    private String lb;//類(lèi)別
    private String name;//姓名
    private Integer age; //年齡
    }

（1）Optional 構(gòu)建

 //返回一個(gè)描述給定值的Optional ，如果不為null ，則返回一個(gè)空的Optional 。
//參數(shù)：值–描述的可能為null值
//類(lèi)型參數(shù)：<T> –值的類(lèi)型
//返回值：一個(gè)Optional與如果指定值是非當(dāng)前值null ，否則一個(gè)空Optional
Optional s1 = Optional.ofNullable(null);
// 構(gòu)建一個(gè)value不可以為null的optional對(duì)象，如果of()的入?yún)閚ull會(huì)報(bào)空指針異常；
Optional<Animal> s2 = Optional.of(new Animal("哺乳動(dòng)物", "小狗",5));
// 構(gòu)建一個(gè)value可以為null的optional對(duì)象；
Optional<Animal> s3 = Optional.ofNullable(null);
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);

輸出結(jié)果：

在這里插入圖片描述

（2）判斷類(lèi)業(yè)務(wù)

 Optional<Animal> myUser1 = Optional.empty();
Optional<Animal> myUser2 = Optional.of(new Animal("哺乳動(dòng)物", "小貓",8));
// filter傳入一個(gè)lambda，lambda返回值為boolean；true:不做任何改變，false:返回一個(gè)空的optional；
Optional<Animal> myUser3 = myUser2.filter(animal -> "小貓".equals(animal.getName()));
Optional<Animal> myUser4 = myUser2.filter(animal -> "小7貓".equals(animal.getName()));
// isPresent就是判斷value是不是null；我們?cè)谡{(diào)用get之前，一定要先調(diào)用isPresent，因?yàn)橹苯尤绻鹶alue是null，直接調(diào)用get會(huì)報(bào)異常；
if (myUser1.isPresent()) {
    Animal value = myUser1.get();
    System.out.println("optional value:" + value);
} else {
    System.out.println("optional value==null");
}
// ifPresent傳入一段lambda，當(dāng)value!=null時(shí)，執(zhí)行里面的邏輯；當(dāng)當(dāng)value==null時(shí)，啥都不干；
myUser2.ifPresent(value -> System.out.println("optional value:" + value));
System.out.println(myUser3);
System.out.println(myUser4);

輸出結(jié)果：

在這里插入圖片描述

（3）獲取類(lèi)業(yè)務(wù)（常用）

Optional<Animal> userInfoEmptyOpt = Optional.empty();
Optional<Animal> userInfoOpt = Optional.of(new Animal("貓科動(dòng)物","哆啦A夢(mèng)",15));
// 1、直接獲取，注意如果value==null，會(huì)報(bào)NoSuchElementException異常
Animal userInfo1 = userInfoOpt.get();
// 2、orElse可以傳入一個(gè)UserInfo類(lèi)型的對(duì)象作為默認(rèn)值;
//    當(dāng)value!=null時(shí)，返回value值；當(dāng)value==null時(shí)，返回默認(rèn)值作為代替；
Animal userInfo2 = userInfoEmptyOpt.orElse(new Animal("貓科動(dòng)物1","哆啦A夢(mèng)",15));
// 3、orElseGet和orElse不同的是orElseGet可以傳入一段lambda表達(dá)式；
// 當(dāng)value!=null時(shí)，返回value值；
// 當(dāng)value==null時(shí)，使用該lambda返回的對(duì)象作為默認(rèn)值；
Animal userInfo3 = userInfoEmptyOpt.orElseGet(() -> new Animal("貓科動(dòng)物2","哆啦A夢(mèng)",15));
// 4、orElseThrow可以傳入一段lambda表達(dá)式，lambda返回一個(gè)Exception；當(dāng)value!=null時(shí)，返回value值；當(dāng)value==null時(shí)，拋出該異常；
Animal userInfo4 = userInfoOpt.orElseThrow(NullPointerException::new);
System.out.println(userInfo1);
System.out.println(userInfo2);
System.out.println(userInfo3);
System.out.println(userInfo4);

輸出結(jié)果：

在這里插入圖片描述

（4）轉(zhuǎn)換類(lèi)業(yè)務(wù)

Optional<Animal> userInfoOpt = Optional.of(new Animal("犬科動(dòng)物","史努比",10));

// 原來(lái)value的類(lèi)型是UserInfo，經(jīng)過(guò)map轉(zhuǎn)換為Optional<String>
Optional<String> username = userInfoOpt.map(Animal::getLb);

// 當(dāng)map的入?yún)⒁彩且粋€(gè)Optional時(shí)，經(jīng)過(guò)map轉(zhuǎn)化后會(huì)形成Optional<Optional<String>>這種嵌套結(jié)構(gòu)；但flatMap可以把這種嵌套結(jié)構(gòu)打平；
Optional<Optional<String>> unFlatMap = userInfoOpt.map(animal -> Optional.of(animal.getLb()));
Optional<String> flatMap = userInfoOpt.flatMap(animal -> Optional.of(animal.getLb()));

System.out.println(username);
System.out.println(unFlatMap);
System.out.println(flatMap);

輸出結(jié)果：

在這里插入圖片描述

6、項(xiàng)目業(yè)務(wù)API測(cè)試

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import java.math.BigDecimal;
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Leader {
    private Long employeeId;
    private BigDecimal bonus;
}
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Employee {
    private Long id;
    private String name;
    private Boolean leader;
}
import java.util.Optional;
 /**
     * 找到ID為1的員工，如果有獎(jiǎng)金就打印出來(lái)，沒(méi)有就打印沒(méi)有獎(jiǎng)金；
     * @throws
     */
public class FiltUtil {
    public void OptionalStudy() {
        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獎(jiǎng)金為：%s", bonus)).orElse("員工ID為1的leader也沒(méi)有獎(jiǎng)金")).ifPresent(System.out::println);
        } else {
            System.out.println("員工ID為1的leader未找到，他可能只是一個(gè)基層員工，不配擁有獎(jiǎng)金");
        }
    }
    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ù)測(cè)試
    public static void main(String[] args) {
        FiltUtil filtUtil = new FiltUtil();
        filtUtil.OptionalStudy();
    }
}

到此這篇關(guān)于Java8中Optional的使用方法詳解的文章就介紹到這了,更多相關(guān)Optional的使用內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: