JDK8新特性-Optional类

最新推荐文章于 2025-07-13 23:19:46 发布

原创最新推荐文章于 2025-07-13 23:19:46 发布 · 2.6k 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#JDK8新特性-Optional类 #JDK8 #Optional

Java基础专栏收录该内容

11 篇文章

订阅专栏

本文介绍了JDK8中的Optional类，旨在解决NullPointException异常。Optional具有empty、of、ofNullable等静态工厂方法，提供了get、isPresent、ifPresent、filter、map、flatMap、orElse和orElseGet等方法来安全地处理可能为null的对象。文章详细讲解了这些方法的使用，帮助开发者更好地利用Optional进行编程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Supplier 接口

JDK8 新增函数是接口
提供一个get方法, 不接收参数, 返回一个参数

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();

Optional

概述

JDK8 新增, 主要用于解决 NullPointException异常
私有构造方法, 不允许通过new 获得一个Optional实例
提供一系列静态工厂方法获得Optional对象
value为空的Optional可以认为是一个空的Optional

API 简介

empty 方法

 
    private static final Optional<?> EMPTY = new Optional<>();
	/*
     * 返回一个空的Optional实例, 这里的空是指value不存在
     */
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

of 方法

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

	/**
     * 返回一个Optional对象, Optional对象的value值为传入的value
     * 如果传入的value为null, 则会抛NullPointException异常
     */
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

ofNullable 方法

    /**
     * 返回一个Optional对象, Optional对象的value为传入的value
     * 如果传入的value为空, 则返回一个空的Optional对象
     * otherwise returns an empty {@code Optional}.
     */
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

get 方法

    /**
     * 如果当前Optional的value存在的话, 就返回value
     * 如果value为null,就抛出NoSuchElementException异常
     *
     * @see Optional#isPresent()
     */
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

isPresent 方法

    /**
     * 判断当前Optional的value是否存在, 存在就返回true
     * 如果当前Optional的value为null则返回false
     * @return {@code true} if there is a value present, otherwise {@code false}
     */
    public boolean isPresent() {
        return value != null;
    }

ifPresent 方法

    /**
     * 接收一个函数式接口Consumer用于处理操作
     * 如果value存在(不为null), 则调用传入的Consumer的accept方法进行处理
     * 如果value不存在(为null), 则什么事都不做
     * 如果传入的Consumer为空的话, 则会抛出NullPointerException异常
     */
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

filter 方法

    /**
     * 接收一个函数式接口Predicate进行条件匹配
     * 如果传入的predicate为空或predicate匹配失败, 则返回一个空的Optional(value为null)
     * 如果传入的predicate匹配成功, 则返回当前的Optional
     */
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }

map 方法

    /**
     * 接收一个函数式接口Function类型的参数对当前的Optional进行一些处理以及类型转换
     * 如果传入的Function类型参数为空, 就抛出NullPointException异常
     * 如果当前的Optional是一个空的Optional, 就返回一个空的Optional(value为空)
	 * 如果Function接口的apply方法执行之后, 返回的结果为null, 同样返回一个空的Optional
     * 当前的Optional中value类型为T, 传入的Function类型为Function<T, U>
     * 返回的新的Optional中value类型为U
     */
    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));
        }
    }

flatMap 方法

    /**
     * 和map方法功能类似, 但是有一些区别, map方法是将T转换成U之后, 再使用Optional.ofNullable方法
     * 获取Optional<U>类型的Optional, flatMap是function的函数完成对T的处理之后, 直接返回一个
     * Optional<U>类型的Optional, 所以如果Function的apply方法返回为空
     * 则会抛出NullPointerException异常
     */
    public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Objects.requireNonNull(mapper.apply(value));
        }
    }

orElse 方法

    /**
     * 如果当前Optional的value存在, 就返回这个value
     * 如果当前Optional的value不存在, 就返回传入的值other
     */
    public T orElse(T other) {
        return value != null ? value : other;
    }

orElseGet 方法

    /**
     * 方法接收一个Supplier<? extends T>参数
     * 如果当前Optional的value存在, 就返回这个value
     * 如果当前Optional的value不存在,则调用other的get方法生成一个
     * 如果other为空, 则抛出NullPointerException异常
     */
    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

API 用法举例

    public static void main(String[] args) {
        // 1. empty 方法
        Optional<String> optional = Optional.empty();
        // 抛出NoSuchElementException
//        System.out.println(optional.get());

        // 2. of 方法 & get方法
        optional = Optional.of("七夜雪");
        System.out.println("2 ---> " + optional.get());

        // 3. isPresent方法
        if (optional.isPresent()) {
            System.out.println("3 ---> " + optional.get());
        }

        // 4. ifPresent, 测试案例3中这种判断方式和现有的先判断是否为null, 再处理是一致的, 更好的一种方式是使用ifPresent
        optional.ifPresent(item -> System.out.println("4 ---> " + item));
        optional = Optional.empty();
        // 这一行因为optional为空, 所以不会执行输出
        optional.ifPresent(item -> System.out.println("4 ---> " + item));

        // 5. filter方法
        optional = Optional.of("七夜雪").filter(item -> "七夜".equals(item));
        System.out.println("5 --->" + optional.isPresent());
        optional = Optional.of("七夜雪").filter(item -> "七夜雪".equals(item));
        System.out.println("5 --->" + optional.isPresent() + ", value : " + optional.get());

        // 6. map 方法
        Optional<Integer> optional1 = Optional.of(1);
        optional = optional1.map(item -> "七夜雪-> " + item);
        System.out.println("6 ---> " + optional.get());
        optional = optional1.map(item -> null);
        System.out.println("6 ---> " + optional.isPresent());
        optional1 = Optional.empty();
        optional = optional1.map(item -> "七夜雪-> " + item);
        System.out.println("6 ---> " + optional.isPresent());

        // 7. flatMap 方法
        optional1 = Optional.of(1);
        optional = optional1.flatMap(item -> Optional.of("七夜雪-> " + item));
        System.out.println("7 ---> " + optional.get());

        // 8. orElse方法
        System.out.println("8 --->" + optional.get());
        optional = Optional.empty();
        System.out.println("8 --->" + optional.orElse("碧落"));

        // 9. orElseGet 方法
        System.out.println("9 --->" + optional.orElseGet(() -> "红尘"));
        optional = Optional.of("七夜雪");
        System.out.println("9 --->" + optional.orElseGet(() -> "红尘"));

        // 10. ofNullable 方法
        optional = Optional.ofNullable(null);
        System.out.println("10 --->" + optional.isPresent());
        optional = Optional.ofNullable("七夜雪");
        System.out.println("10 --->" + optional.isPresent());
    }

输出 :

1 --->false
2 ---> 七夜雪
3 ---> 七夜雪
4 ---> 七夜雪
5 ---> false
5 ---> true, value : 七夜雪
6 ---> 七夜雪-> 1
6 ---> false
6 ---> false
7 ---> 七夜雪-> 1
8 --->七夜雪-> 1
8 ---> 碧落
9 ---> 红尘
9 ---> 七夜雪
10 --->false
10 ---> true