java中Optional的使用详细解析

2024-04-02 19:04:59 907人浏览泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

目录Optional的使用详解1、Optional介绍2、构建Optional3、Optional api 及源码注解4、测试使用4.1、构建4.2、判断类4.3、获取类（常用）4.

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;


public final class Optional<T> {
    
    private static final Optional<?> EMPTY = new Optional<>();

    
    private final T value;

    
    private Optional() {
        this.value = null;
    }

    
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

    
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

    
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

    
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

    
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    
    public boolean isPresent() {
        return value != null;
    }

    
    public boolean isEmpty() {
        return value == null;
    }

    
    public void ifPresent(Consumer<? super T> action) {
        if (value != null) {
            action.accept(value);
        }
    }

    
    public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
        if (value != null) {
            action.accept(value);
        } else {
            emptyAction.run();
        }
    }

    
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent()) {
            return this;
        } else {
            return predicate.test(value) ? this : empty();
        }
    }

    
    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));
        }
    }

    
    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);
        }
    }

    
    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);
        }
    }

    
    public Stream<T> stream() {
        if (!isPresent()) {
            return Stream.empty();
        } else {
            return Stream.of(value);
        }
    }

    
    public T orElse(T other) {
        return value != null ? value : other;
    }

    
    public T orElseGet(Supplier<? extends T> supplier) {
        return value != null ? value : supplier.get();
    }

    
    public T orElseThrow() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    
    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);

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;


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;
    }

    
    @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类详解内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

--结束END--

本文标题: java中Optional的使用详细解析

本文链接: https://lsjlt.com/news/123589.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341