java新特性之Optional的详细解析

optional的使用详解

1、optional介绍

•  optional 类是一个可以为null的容器对象。如果值存在则ispresent()方法会返回true，调用get()方法会返回该对象。
• optional 是个容器：它可以保存类型t的值，或者仅仅保存null。optional提供很多有用的方法，这样我们就不用显式进行空值检测。
• optional 类的引入很好的解决空指针异常。

2、构建optional

构建一个optional对象；方法有：empty( )、of( )、ofnullable( )

 //返回一个描述给定值的optional ，如果不为null ，则返回一个空的optional 。
        //参数：值–描述的可能为null值
        //类型参数：<t> –值的类型
        //返回值：一个optional与如果指定值是非当前值null ，否则一个空optional
        optional.ofnullable("");

        //返回一个optional描述给定的非null值。
        //参数：value –要描述的值，必须为非null
        //类型参数：<t> –值的类型
        //返回值：存在值的optional
        optional.of("");

        //返回一个空的optional实例。 此optional没有值。
        //类型参数：<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() （如果存在值，则执行操作）。
这是一个基于值的类； 在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没有值。
        类型参数：<t> –不存在的值的类型
        返回值：一个空的optional
        api注意：
        尽管这样做可能很诱人，但应通过将==与optional.empty()返回的实例进行比较来避免测试对象是否为空。 不能保证它是一个单例。 而是使用ispresent() 
     */
    public static<t> optional<t> empty() {
        @suppresswarnings("unchecked")
        optional<t> t = (optional<t>) empty;
        return t;
    }

    /**
        使用描述的值构造一个实例。
        参数：值–要描述的非null值
        抛出：nullpointerexception如果值为null
     */
    private optional(t value) {
        this.value = objects.requirenonnull(value);
    }

    /**
        返回一个optional描述给定的非null值。
        参数：value –要描述的值，必须为非null
        类型参数：<t> –值的类型
        返回值：存在值的optiona
     */
    public static <t> optional<t> of(t value) {
        return new optional<>(value);
    }

    /**
        返回一个描述给定值的optional ，如果不为null ，则返回一个空的optional 。
        参数：值–描述的可能为null值
        类型参数：<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;
    }

    /**
        如果存在值，则使用该值执行给定的操作，否则不执行任何操作。
        参数：动作–要执行的动作（如果存在值）
     */
    public void ifpresent(consumer<? super t> action) {
        if (value != null) {
            action.accept(value);
        }
    }

    /**
        如果存在值，则使用该值执行给定的操作，否则执行给定的基于空的操作。
        参数：动作–要执行的动作（如果存在值）emptyaction –要执行的基于空的操作（如果不存在任何值）
        抛出：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 。

        参数：谓词–应用于值的谓词（如果存在）
        返回值：一个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 ），将给定映射函数应用于该值的结果，否则返回一个空的optional 。
        如果映射函数返回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映射函数应用于该值的结果，否则返回一个空的optional 。
        此方法类似于map(function) ，但是映射函数是其结果已经是optional函数，如果调用该函数，则flatmap不会将其包装在其他optional 。

        参数：mapper –应用于值的映射函数（如果存在）
        类型参数：<u> –映射函数返回的optional值的类型
        返回值：施加的结果optional荷瘤映射函数此的值optional ，如果一个值存在，否则一个空optional
        抛出：nullpointerexception如果映射函数为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产生通过供给功能。

        参数：供应商–产生要返回的optional的供应功能
        返回值：返回一个optional描述此的值optional ，如果一个值存在，否则optional所生产的供应功能。
        抛出：nullpointerexception如果提供的函数为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 。

        参数：其他–要返回的值（如果不存在任何值）。 可以为null 。
        返回值：值（如果存在），否则other
     */
    public t orelse(t other) {
        return value != null ? value : other;
    }

    /**
        如果存在值，则返回该值，否则返回由供应函数产生的结果。

        参数：供应商–产生要返回的值的供应函数
        返回值：值（如果存在），否则提供功能产生的结果
     */
    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;
    }

    /**
        如果存在值，则返回该值，否则抛出由异常提供函数产生的异常。

        参数：exceptionsupplier –产生要抛出的异常的提供函数
        类型参数：<x> –引发的异常类型
        返回值：值（如果存在）
        抛出：x –如果不存在任何值nullpointerexception如果不存在任何值并且异常提供函数为null
        api注意：带有空参数列表的对异常构造函数的方法引用可用作提供者
     */
    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 。
//参数：值–描述的可能为null值
//类型参数：<t> –值的类型
//返回值：一个optional与如果指定值是非当前值null ，否则一个空optional
optional s1 = optional.ofnullable(null);

// 构建一个value不可以为null的optional对象，如果of()的入参为null会报空指针异常；
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时，执行里面的逻辑；当当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类型的对象作为默认值;
        //    当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的入参也是一个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

如果存在值，则返回该值，否则抛出由异常提供函数产生的异常。

以前的写法是：

if(inewsmapper.selectnewswithnewscategorybyid(id)==null){
    throw new baseexception(datasourceresponseenum.select_error);
}
else{
    return inewsmapper.selectnewswithnewscategorybyid(id);
}

这种写法是比较丑陋的，为了避免上述丑陋的写法，让丑陋的设计变得优雅。java8提供了optional类来优化这种写法。

例二：

  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，这次看项目的时候，正好遇上了就去好好的康了一番。

我的建议是：喜欢就用，不喜欢就不用。

用的话看起来是会显的更为优雅些，但是缺点也很明显，逻辑性没那么明显了。

到此这篇关于java新特性之optional的详细解析的文章就介绍到这了,更多相关java中optional类详解内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！