Java8 Optional的使用详解

时间:2021-2-20 作者:admin

Optional介绍

Optional是Jdk1.8提供的一个新类,希望可以通过该类的引入解决令人烦躁的null判断问题,非常好用。个人理解:这个类是一个包装类,将要操作的java bean封装到该类的对象里面,同时将一些常用的判断逻辑封装为成员方法,结合lambda语法,实现比较优雅的链式调用。现在对Optional的API使用做一个简单的说明。

API介绍

Optional的所有的方法如下图所示,这些API大致可以分为以下几类:

1、构建API:构建一个Optional对象;方法有:empty( )、of( )、ofNullable( );

2、获取API:获取Optional对象里包装的值;方法有:get( )、orElse( )、orElseGet( )、orElseThrow( );

3、转换API:将Optional对象里包装的值转换成一个新的值;方法有:map( )、flatMap( );

4、判断API:对Optional对象里包装的值做一些逻辑判断;方法有:filter( )、isPresent( )、ifPresent( );
Java8 Optional的使用详解

API使用方法

首先准备一个pojo类

@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@ToString
public class UserInfo {
    private String username;
    private String password;
    private Integer age;
    private String gender;
}

构建类

	@Test
    public void testBuildOptional() {
        // 构建一个value为null的optional对象;
        Optional<UserInfo> userInfoEmptyOpt = Optional.empty();

        // 构建一个value不可以为null的optional对象,如果of()的入参为null会报空指针异常;
        Optional<UserInfo> userInfoOpt = Optional.of(new UserInfo("阿飞","123456", 15, "man"));

        // 构建一个value可以为null的optional对象;
        Optional<UserInfo> userInfoNullOpt = Optional.ofNullable(null);

        System.out.println(userInfoEmptyOpt);
        System.out.println(userInfoOpt);
        System.out.println(userInfoNullOpt);
        
//        输出如下:
//        Optional.empty
//        Optional[UserInfo(username=阿飞, password=123456, age=15, gender=man)]
//        Optional.empty
    }

获取类

	@Test
    public void testGetOptionalValue() {
        Optional<UserInfo> userInfoEmptyOpt = Optional.empty();
        Optional<UserInfo> userInfoOpt = Optional.of(new UserInfo("阿飞","123456", 15, "man"));

        // 直接获取,注意如果value==null,会报NoSuchElementException异常
        UserInfo userInfo1 = userInfoOpt.get();
        // orElse可以传入一个UserInfo类型的对象作为默认值;当value!=null时,返回value值;当value==null时,返回默认值作为代替;
        UserInfo userInfo2 = userInfoEmptyOpt.orElse(new UserInfo("阿飞1","123456", 15, "man"));
        // orElseGet和orElse不同的是orElseGet可以传入一段lambda表达式;当value!=null时,返回value值;当value==null时,使用该lambda返回的对象作为默认值;
        UserInfo userInfo3 = userInfoEmptyOpt.orElseGet(() -> new UserInfo("阿飞2","123456", 15, "man"));
        // orElseThrow可以传入一段lambda表达式,lambda返回一个Exception;当value!=null时,返回value值;当value==null时,抛出该异常;
        UserInfo 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, age=15, gender=man)
        // UserInfo(username=阿飞1, password=123456, age=15, gender=man)
        // UserInfo(username=阿飞2, password=123456, age=15, gender=man)
        // UserInfo(username=阿飞, password=123456, age=15, gender=man)
    }

转换类

	@Test
    public void testMapOptionalValue() {
        Optional<UserInfo> userInfoOpt = Optional.of(new UserInfo("阿飞","123456", 15, "man"));

        // 原来value的类型是UserInfo,经过map转换为Optional<String>
        Optional<String> username = userInfoOpt.map(UserInfo::getUsername);

        // 当map的入参也是一个Optional时,经过map转化后会形成Optional<Optional<String>>这种嵌套结构;但flatMap可以把这种嵌套结构打平;
        Optional<Optional<String>> unFlatMap = userInfoOpt.map(user -> Optional.of(user.getUsername()));
        Optional<String> flatMap = userInfoOpt.flatMap(user -> Optional.of(user.getUsername()));

        System.out.println(username);
        System.out.println(unFlatMap);
        System.out.println(flatMap);
        
        // 输出如下:
        // Optional[阿飞]
        // Optional[Optional[阿飞]]
        // Optional[阿飞]
    }

判断类

	@Test
    public void testJudgeOptionalValue() {
        Optional<UserInfo> userInfoEmptyOpt = Optional.empty();
        Optional<UserInfo> userInfoOpt = Optional.of(new UserInfo("阿飞", "123456", 15, "man"));

        // filter传入一个lambda,lambda返回值为boolean;true:不做任何改变,false:返回一个空的optional;
        Optional<UserInfo> userInfo = userInfoOpt.filter(user -> "错误的密码".equals(user.getPassword()));
        System.out.println(userInfo);

        // isPresent就是判断value是不是null;我们在调用get之前,一定要先调用isPresent,因为直接如果value是null,直接调用get会报异常;
        if (userInfoEmptyOpt.isPresent()) {
            UserInfo value = userInfoEmptyOpt.get();
            System.out.println("optional value:" + value);
        } else {
            System.out.println("optional value==null");
        }

        // ifPresent传入一段lambda,当value!=null时,执行里面的逻辑;当当value==null时,啥都不干;
        userInfoOpt.ifPresent(value -> System.out.println("optional value:" + value));
        
        // 输入如下:
        // Optional.empty
        // optional value==null
        // optional value:UserInfo(username=阿飞, password=123456, age=15, gender=man)
    }

试一下这些API吧

package com.fly.optional;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import org.junit.Test;
import org.omg.CosNaming.NamingContextPackage.NotFound;

import java.math.BigDecimal;
import java.util.Optional;

public class OptionDemo {

    @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 NotFound
     */
    @Test
    public void tst() throws NotFound {
        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();
    }
}

声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。