第十三章 Optional类的使用-CSDN博客

isPresent() : 判断是否包含值，包含值返回true，不包含值返回false

get() : 如果Optional有值则将其返回，否则抛出NoSuchElementException

orElse(T t) : 如果调用对象包含值，返回该值，否则返回参数t

orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值

map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()

3.3. 常规使用

package com.wzx;

import java.util.Optional;

public class Test {
    public static void main(String[] args) {
        Optional<String> userName1 = Optional.of("凤姐");
        System.out.println("userName1:" + userName1.get());
//        Optional<String> userName2 = Optional.of(null);
//        System.out.println("userName2:" + userName2.get());
//        Optional<String> userName3 = Optional.ofNullable(null);
//        System.out.println("userName3:" + userName3.get());
        Optional<String> userName4 = Optional.empty();
        // isPresent() : 判断是否包含值,包含值返回true，不包含值返回false。
        if (userName4.isPresent()) {
        // get() : 如果Optional有值则将其返回，否则抛出NoSuchElementException。
            String userName = userName4.get();
            System.out.println("用户名为:" + userName);
        } else {
            System.out.println("用户名不存在");
        }
    }
}

3.4. Optional的高级使用

import org.junit.Test;

import java.util.Optional;

public class StreamTest {
    @Test
    public void test03() {
        Optional<String> userNameO = Optional.of("凤姐");
        // Optional<String> userNameO = Optional.empty();
        // 存在做的什么
        // userNameO.ifPresent(s -> System.out.println("用户名为" + s));
        // 存在做的什么,不存在做点什么
        userNameO.ifPresentOrElse(s -> System.out.println("用户名为" + s)
                , () -> System.out.println("用户名不存在"));
    }
    @Test
    public void test04() {
        // Optional<String> userNameO = Optional.of("凤姐");
        Optional<String> userNameO = Optional.empty();
        // 如果调用对象包含值，返回该值，否则返回参数t
        System.out.println("用户名为" + userNameO.orElse("null"));
        // 如果调用对象包含值，返回该值，否则返回参数Supplier得到的值
        String s1 = userNameO.orElseGet(() -> {return "未知用户名";});
        System.out.println("s1 = " + s1);
    }
}

四、练习

package com.wzx;

import java.util.Optional;

public class Test {
    public static void main(String[] args) {

    }

    @org.junit.Test
    public void OptonalTest() {
        // Optional是什么，如何用？
        // 创建一个 Optional 实例
        Optional.of(new User());
        // Optional.ofNullable(T t):若 t 不为 null，创建 Optional 实例，否则创建空实例
        Optional<User> optional = Optional.ofNullable(new User(4, "yll"));
        // 创建一个空的 Optional 实例
        Optional<Object> empty = Optional.empty();

        User user = new User(1, "王哲晓");
        if (user != null) {
            String name = user.getName();
            System.out.println("我们应该活在自由和热爱里，别浪费了人生这张门票! 普通方法：" + name);
        }

        // Optional常见的"错误/即不够优雅"用法
        Optional<User> optionalUser = Optional.ofNullable(user);
        if (optionalUser.isPresent()) {
            User thisUser = optionalUser.get();
            System.out.println("我们应该活在自由和热爱里，别浪费了人生这张门票! optional: " + thisUser.getName());
        }

        // Optional正确用法
//        optionalUser.map(new Function<User, Object>() {
//            @Override
//            public Object apply(User user) {
//                return user.getName();
//            }
//        });
        // 上述代码简化后
//        optionalUser.map(User::getName).ifPresent(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });
        // 上述代码简化后
        optionalUser.map(User::getName).ifPresent(System.out::println);

        User user2 = new User(2, "王宝强");
        // Optional常见的"错误/即不够优雅"用法
        Optional<User> optionalUser2 = Optional.ofNullable(user2);
        // 如果存在，则干点啥
        optionalUser2.ifPresent(this::palyer); // 玩王宝强

        // orElse 和 orElseGet 的区别
        // 不管当前的值是不是为空，都会执行orElse中的内容
        User user3 = optionalUser2.orElse(palyer()); // 玩
        // 如果传入的user2为空时，才执行orElseGet中的内容，恶汉式
        User user4 = optionalUser2.orElseGet(this::palyer); // 这种用的比较多

        Optional.ofNullable(null).orElse(watch(new User(4, "wangwei")));

        // 过滤
        optionalUser2.filter(user1 -> user1.getName().length() > 2)
                .ifPresent(u -> System.out.println(u.getName() + "filter"));

        // map 和 flatMap 的区别
        // flatMap会直接拆包，将String输出来
        Optional<String> u1 = optional.flatMap(u11 -> getUserName(u11));
        System.out.println("u1: " + u1); // u1: Optional[yll]
        // map会包一层Optional
        Optional<Optional<String>> u2 = optional.map(u11 -> getUserName(u11));
        System.out.println("u2: " + u2); // u2: Optional[Optional[yll]]
    }

    public void palyer(User user) {
        System.out.println("玩" + user.getName());
    }

    public User palyer() {
        System.out.println("玩");
        User user = new User(1, "");
        return user;
    }

    public void eat(User user) {
        System.out.println("吃香喝辣");
    }

    public User watch(User user) {
        System.out.println("看世界"+user.getName());
        return user;
    }

    private Optional<String> getUserName(User user) {
        return Optional.ofNullable(user).map(u -> u.getName());
    }
}