0
点赞
收藏
分享

微信扫一扫

Java：Optional处理NullPointerException空指针异常的利器

流计算Alink 2023-05-19 阅读 81
SystemjavaTestJava后端开发yyds干货盘点

代码运行环境

$ java -version
java version "1.8.0_251"
Java(TM) SE Runtime Environment (build 1.8.0_251-b08)
Java HotSpot(TM) 64-Bit Server VM (build 25.251-b08, mixed mode)

(目录)

1、empty()

empty 方法返回一个不包含值的 Optional 实例

Optional empty = Optional.empty();
System.out.println(empty);
// Optional.empty

2、of()

of 方法会返回一个 Optional 实例

  • 如果传入的值非空，会返回包含指定值的对象；
  • 如果传入空，会立刻抛出空指针异常。
Optional<String> name = Optional.of("Tom");
System.out.println(name);
// Optional[Tom]

Optional.of(null);
// java.lang.NullPointerException

3、ofNullable()

ofNullable 方法会返回一个 Optional 实例

  • 如果传入的值非空，会返回包含指定值的对象；
  • 如果传入空，会返回不包含任何值的 empty 对象，也就是最开始介绍的Optional.empty()对象。
Optional<String> name = Optional.ofNullable("Tom");
System.out.println(name);
// Optional[Tom]

Optional<Object> optional = Optional.ofNullable(null);
System.out.println(optional);
// Optional.empty

4、isPresent()

isPresent 方法用来判断实例是否包含值

  • 如果包含非空值，返回 true
  • 否则返回 false
boolean isPresent1 = Optional.ofNullable("Tom")
        .isPresent();
System.out.println(isPresent1);
// true

boolean isPresent2 = Optional.ofNullable(null)
        .isPresent();
System.out.println(isPresent2);
// false

5、get()

get 方法

  • 如果实例包含非空值，则返回当前值；
  • 否则抛出 NoSushElementException 异常。
String tom = Optional.ofNullable("Tom")
        .get();
System.out.println(tom);
// Tom

Optional.ofNullable(null)
        .get();
// java.util.NoSuchElementException: No value present

6、ifPresent()

ifPresent 方法

  • 当实例包含非空值时，执行传入的 Consumer，比如调用一些其他方法；
  • 如果包含的值为空，不执行任何操作。
Optional.ofNullable("Tom")
        .ifPresent(x -> {
            System.out.println(x);
            // Tom
        });


Optional.ofNullable(null)
        .ifPresent(x -> {
            System.out.println(x);
            // 没有任何输出
        });

7、filter()

filter 方法用于过滤不符合条件的值，接收一个Predicate参数，

  • 如果符合条件，会返回当前的Optional实例，
  • 否则返回 empty 实例。
Optional<String> optional1 = Optional.ofNullable("Tom")
        .filter(x -> x.contains("T"));
System.out.println(optional1);
// Optional[Tom]


Optional<String> optional2 = Optional.ofNullable("Tom")
        .filter(x -> x.contains("J"));
System.out.println(optional2);
// Optional.empty

8、map()

map 方法是链式调用避免空指针的核心方法

  • 当实例包含值时，对值执行传入的Function函数接口方法，并返回一个代表结果值新的Optional实例，也就是将返回的结果再次包装成Optional对象。
Optional<String> optional1 = Optional.ofNullable("Tom")
        .map(x -> {
            return "hi " + x;
        });
System.out.println(optional1);
// Optional[hi Tom]

Optional<String> optional2 = Optional.ofNullable(null)
        .map(x -> {
            return "hi " + x;
        });
System.out.println(optional2);
// Optional.empty

9、flatMap()

flatMap 方法与 map 方法类似， 唯一不同的地方在于：需要手动将返回的值，包装成Optional实例，并且参数值不允许为空。

Optional<String> optional1 = Optional.ofNullable("Tom")
        .flatMap(x -> {
            return Optional.of("hi " + x);
        });

System.out.println(optional1);
// Optional[hi Tom]


Optional<String> optional2 = Optional.ofNullable(null)
        .flatMap(x -> {
            return Optional.of("hi " + x);
        });

System.out.println(optional2);
// Optional.empty

10、orElse()

orElse 方法

  • 如果实例包含非空值，那么返回当前值；
  • 否则返回指定的默认值。
String name1 = Optional.ofNullable("Tom")
        .orElse("Jack");
System.out.println(name1);
// Tom

Object name2 = Optional.ofNullable(null)
        .orElse("Jack");
System.out.println(name2);
// Jack

11、orElseGet()

orElseGet 方法

  • 如果实例包含非空值，返回这个值；
  • 否则，它会执行作为参数传入的Supplier函数式接口方法，并返回其执行结果。
String name1 = Optional.ofNullable("Tom")
        .orElseGet(() -> {
            return "Jack";
        });

System.out.println(name1);
// Tom


Object name2 = Optional.ofNullable(null)
        .orElseGet(() -> {
            return "Jack";
        });

System.out.println(name2);
// Jack

12、orElseThrow()

orElseThrow 方法

  • 如果实例包含非空值，返回这个值；
  • 否则，它会执行作为参数传入的异常类。
String name1 = Optional.ofNullable("Tom")
        .orElseThrow(() -> new RuntimeException("参数为空"));

System.out.println(name1);
// Tom

Object name2 = Optional.ofNullable(null)
        .orElseThrow(() -> new RuntimeException("参数为空"));

System.out.println(name2);
// java.lang.RuntimeException: 参数为空

完整代码

package com.example.demo;

import org.junit.jupiter.api.Test;

import java.util.Optional;

public class OptionalTest {
    @Test
    public void testOptionalEmpty() {
        Optional empty = Optional.empty();
        System.out.println(empty);
        // Optional.empty
    }

    @Test
    public void testOptionalOf() {
        Optional<String> name = Optional.of("Tom");
        System.out.println(name);
        // Optional[Tom]

        Optional.of(null);
        // java.lang.NullPointerException
    }

    @Test
    public void testOptionalOfNullable() {
        Optional<String> name = Optional.ofNullable("Tom");
        System.out.println(name);
        // Optional[Tom]

        Optional<Object> optional = Optional.ofNullable(null);
        System.out.println(optional);
        // Optional.empty
    }

    @Test
    public void testOptionalIsPresent() {
        boolean isPresent1 = Optional.ofNullable("Tom")
                .isPresent();
        System.out.println(isPresent1);
        // true

        boolean isPresent2 = Optional.ofNullable(null)
                .isPresent();
        System.out.println(isPresent2);
        // false
    }

    @Test
    public void testOptionalGet() {
        String tom = Optional.ofNullable("Tom")
                .get();
        System.out.println(tom);
        // Tom

        Optional.ofNullable(null)
                .get();
        // java.util.NoSuchElementException: No value present
    }

    @Test
    public void testOptionalIfPresent() {
        Optional.ofNullable("Tom")
                .ifPresent(x -> {
                    System.out.println(x);
                    // Tom
                });


        Optional.ofNullable(null)
                .ifPresent(x -> {
                    System.out.println(x);
                    // 没有任何输出
                });
    }

    @Test
    public void testOptionalFilter() {
        Optional<String> optional1 = Optional.ofNullable("Tom")
                .filter(x -> x.contains("T"));
        System.out.println(optional1);
        // Optional[Tom]


        Optional<String> optional2 = Optional.ofNullable("Tom")
                .filter(x -> x.contains("J"));
        System.out.println(optional2);
        // Optional.empty
    }

    @Test
    public void testOptionalMap() {
        Optional<String> optional1 = Optional.ofNullable("Tom")
                .map(x -> {
                    return "hi " + x;
                });
        System.out.println(optional1);
        // Optional[hi Tom]


        Optional<String> optional2 = Optional.ofNullable(null)
                .map(x -> {
                    return "hi " + x;
                });
        System.out.println(optional2);
        // Optional.empty
    }

    @Test
    public void testOptionalFlatMap() {
        Optional<String> optional1 = Optional.ofNullable("Tom")
                .flatMap(x -> {
                    return Optional.of("hi " + x);
                });

        System.out.println(optional1);
        // Optional[hi Tom]


        Optional<String> optional2 = Optional.ofNullable(null)
                .flatMap(x -> {
                    return Optional.of("hi " + x);
                });

        System.out.println(optional2);
        // Optional.empty
    }

    @Test
    public void testOptionalOrElse() {
        String name1 = Optional.ofNullable("Tom")
                .orElse("Jack");
        System.out.println(name1);
        // Tom

        Object name2 = Optional.ofNullable(null)
                .orElse("Jack");
        System.out.println(name2);
        // Jack

    }

    @Test
    public void testOptionalOrElseGet() {
        String name1 = Optional.ofNullable("Tom")
                .orElseGet(() -> {
                    return "Jack";
                });

        System.out.println(name1);
        // Tom

        Object name2 = Optional.ofNullable(null)
                .orElseGet(() -> {
                    return "Jack";
                });

        System.out.println(name2);
        // Jack
    }

    @Test
    public void testOptionalOrElseThrow() {
        String name1 = Optional.ofNullable("Tom")
                .orElseThrow(() -> new RuntimeException("参数为空"));

        System.out.println(name1);
        // Tom

        Object name2 = Optional.ofNullable(null)
                .orElseThrow(() -> new RuntimeException("参数为空"));

        System.out.println(name2);
        // java.lang.RuntimeException: 参数为空
    }
}

参考 【Java 8系列】Java开发者的判空利器 -- Optional Optional 是个好东西，你真的会用么？

举报

相关推荐

NullPointerException空指针异常

空指针异常初始化数组Linux系统/运维

关于NullPointerException空指针异常的解决办法

javaspringmaven

Optional避免判空嵌套过多，优雅解决空指针异常

linux

[Java]如何在工作中避免空指针异常(NullPointerException)

日记本JavaJAVA

java空指针异常

java空指针异常代码段Java编程语言

学习Java时可能会遇到的空指针异常java.lang.NullPointerException

java数据结构数组空指针异常对象数组编程语言

java中的空指针异常

java开发语言后端

Java代码规范及异常汇总 非空异常 NullPointerException

Systemjava赋值Python后端开发

空指针异常

空指针异常Java异常处理后端开发yyds干货盘点

Controller调Service报空指针NullPointerException

java经验分享
0 条评论