专栏首页Kevin-ZhangCGJava8中使用Optional处理null对象

Java8中使用Optional处理null对象

系统环境:

  • Java JDK 版本:1.8

参考地址:

  • Oracle JDK API 参考文档

https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html

  • 菜鸟教程-Java 8 Optional 类

https://www.runoob.com/java/java8-optional-class.html

1.Optional简介

  Optional 是一个容器对象,可以存储对象、字符串等值,当然也可以存储 null 值。Optional 提供很多有用的方法,能帮助我们将 Java 中的对象等一些值存入其中,这样我们就不用显式进行空值检测,使我们能够用少量的代码完成复杂的流程。

比如它提供了:

  • of() 方法,可以将值存入 Optional 容器中,如果存入的值是 null 则抛异常。
  • ofNullable() 方法,可以将值存入 Optional 容器中,即使值是 null 也不会抛异常。
  • get() 方法,可以获取容器中的值,如果值为 null 则抛出异常。
  • getElse() 方法,可以获取容器中的值,如果值为 null 则返回设置的默认值。
  • isPresent() 方法,该方法可以判断存入的值是否为空。
  • …等等一些其它常用方法,下面会进行介绍。

可以说,使用 Optional 可以帮助我们解决业务中,减少值动不动就抛出空指针异常问题,也减少 null 值的判断,提高代码可读性等,这里我们介绍下,如果使用这个 Optional 类。

2.Optional类描述

  • Optional 类所在包: java.util.Optional
  • Optional 类声明: public final class Optional extends Object
  • Optional 类方法: public Optional filter(Predicate<? super T> predicate)

  简单来说,Opitonal类就是Java提供的为了解决大家平时判断对象是否为空用会用 null!=obj 这样的方式存在的判断,从而令人头疼导致NPE(Null Pointer Exception 空指针异常),同时Optional的存在可以让代码更加简单,可读性跟高,代码写起来更高效.

常规判断:

//对象 人
//属性有 name,age
Person person=new Person();
if (null==person){
   return "person为null";
}
return person;

使用Optional:

//对象 人
//属性有 name,age
Person person=new Person();
return Optional.ofNullable(person).orElse("person为null");

3、Optional 常用方法及使用示例

1、静态方法 Optional.of()

  • 方法作用: 为指定的值创建一个指定非 null 值的 Optional。
  • 方法描述: of 方法通过工厂方法创建 Optional 实例,需要注意的是传入的参数不能为 null,否则抛出 NullPointerException。
  • 返回类型: Optional
  • 示例代码:

调用两个 Optional.of() 方法,一个传入正常参数,另一个传入 null 参数:

public static void main(String[] args) {
    // 传入正常值,正常返回一个 Optional 对象
    Optional<String> optional1 = Optional.of("mydlq");
    
    // 传入参数为 null,抛出 NullPointerException.
    Optional optional2 = Optional.of(null);
}

运行代码,可以观察到控制台输出内容如下:

Exception in thread "main" java.lang.NullPointerException
    at java.util.Objects.requireNonNull(Objects.java:203)
    at java.util.Optional.<init>(Optional.java:96)
    at java.util.Optional.of(Optional.java:108)
    at club.mydlq.OptionalExample.main(OptionalExample.java:12)

可以看到传入正常参数正常返回 Optional 对象,传入 null 参数返回 NullPointerException 异常。

2、静态方法 Optional.ofNullable()

  • 方法作用: 为指定的值创建一个 Optional 对象,如果指定的参数为 null,不抛出异常,直接则返回一个空的 Optional 对象。
  • 方法描述: ofNullable 方法是和 of 方式一样,都是用于创建 Optional 对象,只是传入的参数 null 时,会返回一个空的 Optional 对象,而不会抛出 NullPointerException 异常。
  • 返回类型: Optional
  • 示例代码:

调用 Optional.ofNullable() 方法,传入 null 参数:

public static void main(String[] args) {
    // 传入正常值,正常返回一个 Optional 对象
    Optional<String> optional1 = Optional.ofNullable("mydlq");
    
    // 传入 null 参数,正常返回 Optional 对象
    Optional optional2 = Optional.ofNullable(null);
}

运行代码,可以观察到正常传入值和传入 null 值时,都没有抛出异常。

3、对象方法 isPresent()

  • 方法作用: 如果值存在则方法会返回 true,否则返回 false。
  • 方法描述: 该方法其实就是用于判断创建 Optional 时传入参数的值是否为空,实现代码就简单一行,即 value != null 所以如果不为空则返回 true,否则返回 false。
  • 返回类型: boolean
  • 示例代码:
public static void main(String[] args) {
    // 传入正常值,正常返回一个 Optional 对象,并使用 isPresent 方法
    Optional optional1 = Optional.ofNullable("mydlq");
    System.out.println("传入正常值返回:" + optional1.isPresent());

    // 传入参数为 null 生成一个 Optional 对象,并使用 isPresent 方法
    Optional optional2 = Optional.ofNullable(null);
    System.out.println("传入 null 值返回:" + optional2.isPresent());
}

运行代码,可以观察到控制台输出内容如下:

传入正常值返回:true
传入 null 值返回:false

可以看到传入正常参数时调用 Optional 对象的 isPresent 方法时返回 true,传入 null 参数返回 false。

4、对象方法 get()

  • 方法作用: 如果 Optional 有值则将其返回,否则抛出 NoSuchElementException 异常。
  • 方法描述: get 方法内部实现其实就是判断 Otpional 对象中的 value 属性是否为 null,如果是就抛出 NoSuchElementException 异常,否则返回这个 value 值。
  • 返回类型: T
  • 示例代码:
public static void main(String[] args) {
    // 传入正常值,正常返回一个 Optional 对象,并使用 get 方法获取值
    Optional optional1 = Optional.ofNullable("mydlq");
    System.out.println(optional1.get());

    // 传入参数为 null 生成一个 Optional 对象,并使用 get 方法获取值
    Optional optional2 = Optional.ofNullable(null);
    System.out.println(optional2.get());
}

运行代码,可以观察到控制台输出内容如下:

传入正常参数:mydlq
Exception in thread "main" java.util.NoSuchElementException: No value present
    at java.util.Optional.get(Optional.java:135)
    at club.mydlq.OptionalExample.main(OptionalExample.java:14)

可以观察到传入正常值的 Optional 调用 get 方法正常输出值,通过空的 optional 对象使用 get 方法获取值时,抛出 NoSuchElementException 异常:

5、对象方法 ifPresent()

  • 方法作用: 如果值存在则使用该值调用 consumer , 否则不做任何事情。
  • 方法描述: 该方法 ifPresent(Consumer<? super T> consumer) 中参数接收的是 Consumer 类,它包含一个接口方法 accept(),该方法能够对传入的值进行处理,但不会返回结果。这里传入参数可以传入 Lamdda 表达式或 Consumer 对象及实现 Consumer 接口的类的对象。
  • 返回类型: void
  • 示例代码:
public static void main(String[] args) {
    // 创建 Optional 对象,然后调用 Optional 对象的 ifPresent 方法,传入 Lambda 表达式
    Optional optional1 = Optional.ofNullable("mydlq1");
    optional1.ifPresent((value) -> System.out.println("Optional 的值为:" + value));

    // 创建 Optional 对象,调用 Optional 对象的 ifPresent 方法,传入实现 Consumer 匿名内部类
    Optional optional2 = Optional.ofNullable("mydlq2");
    Consumer<String> consumer = new Consumer() {
        @Override
        public void accept(Object value) {
            System.out.println("Optional 的值为:" + value);
        }
    };
    optional2.ifPresent(consumer);
}

运行代码,可以观察到控制台输出内容如下:

Optional 的值为:mydlq1
Optional 的值为:mydlq2

可以观察到,调用 ifPresent 使用 lambda 或者内部匿名类方法,都是为了再执行 Optional 对象的 ifPresent 方法时,执行一段代码逻辑。

6、对象方法 orElse()

  • 方法作用: 如果该值存在就直接返回, 否则返回指定的其它值。
  • 方法描述: orElse 方法实现很简单,就是使用三目表达式对传入的参数值进行 null 验证,即 value != null ? value : other; 如果为 null 则返回 true,否则返回 false。
  • 返回类型: T
  • 示例代码:
public static void main(String[] args) {
    // 传入正常参数,获取一个 Optional 对象,并使用 orElse 方法设置默认值
    Optional optional1 = Optional.ofNullable("mydlq");
    Object object1 = optional1.orElse("默认值");
    System.out.println("如果值不为空:"+object1);

    // 传入 null 参数,获取一个 Optional 对象,并使用 orElse 方法设置默认值
    Optional optional2 = Optional.ofNullable(null);
    Object object2 = optional2.orElse("默认值");
    System.out.println("如果值为空:"+object2);
}

运行代码,可以观察到控制台输出内容如下:

如果值不为空:mydlq
如果值为空:默认值

可以观察到,如果 Optional 的值为空,则返回 orElse() 方法设置的默认值,否则返回 Optional 中的值。

7、对象方法 orElseGet()

  • 方法作用: 如果该值存在就返回值,否则触发 other,并返回 other 调用的结果。
  • 方法描述: orElseGet 方法和 orElse 方法类似,都是在 Optional 值为空时,返回一个默认操作,只不过 orElse 返回的是默认值,而 orElseGet 是执行 lambda 表达式,然后返回 lambda 表达式执行后的结果。
  • 返回类型: T
  • 示例代码:
public static void main(String[] args) {
    // 传入正常参数,获取一个 Optional 对象,并使用 orElse 方法设置默认值
    Optional optional1 = Optional.ofNullable("mydlq");
    Object object1 = optional1.orElseGet(() -> {
        String defaultVal = "执行逻辑和生成的默认值";
        return defaultVal;
    });
    System.out.println("输出的值为:"+object1);

    // 传入 null 参数,获取一个 Optional 对象,并使用 orElse 方法设置默认值
    Optional optional2 = Optional.ofNullable(null);
    Object object2 = optional2.orElseGet(() -> {
        String defaultVal = "执行逻辑和生成的默认值";
        return defaultVal;
    });
    System.out.println("输出的值为:"+object2);
}

运行代码,可以观察到控制台输出内容如下:

输出的值为:mydlq
输出的值为:执行逻辑和生成的默认值

可也观察到,当 Optional 值为不为空时正常返回带值的 Optional,如果 Optional 为空则返回 orElseGet 方法中 lambda 表达式执行后生成的值。

8、对象方法 orElseThrow()

  • 方法作用: 如果 Optional 存在该值,返回包含的值,否则抛出由 Supplier 继承的异常。
  • 方法描述: orElseThrow 方法其实就是判断创建 Optional 时传入的参数是否为 null,如果是非 null 则返回传入的值,否则抛出 异常。
  • 返回类型: T
  • 示例代码:
public static void main(String[] args) {
    // 传入正常参数,获取一个 Optional 对象,并使用 orElseThrow 方法
    try {
        Optional optional1 = Optional.ofNullable("mydlq");
        Object object1 = optional1.orElseThrow(() -> {
                    System.out.println("执行逻辑,然后抛出异常");
                    return new RuntimeException("抛出异常");
                }
        );
        System.out.println("输出的值为:" + object1);
    } catch (Throwable throwable) {
        throwable.printStackTrace();
    }
    
    // 传入 null 参数,获取一个 Optional 对象,并使用 orElseThrow 方法
    try {
        Optional optional2 = Optional.ofNullable(null);
        Object object2 = optional2.orElseThrow(() -> {
                    System.out.println("执行逻辑,然后抛出异常");
                    return new RuntimeException("抛出异常");
                }
        );
        System.out.println("输出的值为:" + object2);
    } catch (Throwable throwable) {
        throwable.printStackTrace();
    }
}

运行代码,可以观察到控制台输出内容如下:

值为不为空输出的值:mydlq
执行逻辑,然后抛出异常
java.lang.RuntimeException: 抛出异常
    at club.mydlq.OptionalExample.lambda$main$1(OptionalExample.java:25)
    at java.util.Optional.orElseThrow(Optional.java:290)
    at club.mydlq.OptionalExample.main(OptionalExample.java:23)

可以观察到,当创建 Optional 时如果传入的参数为空则执行 Lambda 表达式代码逻辑后抛出异常信息,否则返回传入的参数值。

9、对象方法 map()

  • 方法作用: 如果有值,则对其执行调用映射函数得到返回值。如果返回值不为 null,则创建包含映射返回值的 Optional 作为 map 方法返回值,否则返回空 Optional。
  • 方法描述: map 方法主要用于获取某个对象中的某个属性值的 Optional 对象时使用。map 方法调用时,首先验证传入的映射函数是否为空,如果为空则抛出异常。然后,再检测 Optional 的 value 是否为空,如果是,则返回一个空 value 的 Optional 对象。如果传入的映射函数和 Optinal 的 value 都不为空,则返回一个带 value 对象属性的 Optional 对象。
  • 返回类型: Optional<U>
  • 示例代码:

示例1: 创建 Map 集合,存储一些键值对信息,通过 Optional 操作 Map 获取值,然后观察:

public static void main(String[] args) {
    // 创建 map 对象
    Map<String, String> userMap = new HashMap<>();
    userMap.put("name1", "mydlq");
    userMap.put("name2", null);

    // 传入 Map 对象参数,获取一个 Optional 对象,获取 name1 属性
    Optional<String> optional1 = Optional.of(userMap).map(value -> value.get("name1"));

    // 传入 Map 对象参数,获取一个 Optional 对象,获取 name2 属性
    Optional<String> optional2 = Optional.of(userMap).map(value -> value.get("name2"));

    // 获取 Optional 的值
    System.out.println("获取的 name1 的值:" + optional1.orElse("默认值"));
    System.out.println("获取的 name2 的值:" + optional2.orElse("默认值"));
}

运行代码,可以观察到控制台输出内容如下:

获取的 Optional 的值:mydlq
获取的 Optional 的值:默认值

示例2: 创建一个用户类,使用 Optional 操作用户对象,获取其 name 参数,结合 Optional 的 map 方法获取值,进行观察:

public class User {

    private String name;
    
    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

使用 Optional 的 map 方法对值处理:

public static void main(String[] args) {
    // 创建一个对象,设置姓名属性而不设置性别,这时候性别为 null
    User user1 = new User("测试名称");
    User user2 = new User();

    // 使用 Optional 存储 User 对象
    Optional<User> optional1 = Optional.ofNullable(user1);
    Optional<User> optional2 = Optional.ofNullable(user2);

    // 获取对象的 name 属性值
    String name1 = optional1.map(User::getName).orElse("未填写");
    String name2 = optional2.map(User::getName).orElse("未填写");

    // 输出结果
    System.out.println("获取的名称:" + name1);
    System.out.println("获取的名称:" + name2);
}

运行代码,可以观察到控制台输出内容如下:

获取的名称:测试名称
获取的名称:未填写

总结:

通过上面两个示例观察到,通过 Optional 对象的 map 方法能够获取映射对象中的属,创建 Optional 对象,并以此属性充当 Optional 的值,结合 orElse 方法,如果获取的属性的值为空,则设置个默认值。

10、对象方法 flatMap()

  • 方法作用: 如果值存在,返回基于 Optional 包含的映射方法的值,否则返回一个空的 Optional。
  • 方法描述: flatMap 方法和 map 方法类似,唯一的不同点就是 map 方法会对返回的值进行 Optional 封装,而 flatMap 不会,它需要手动执行 Optional.of 或 Optional.ofNullable 方法对 Optional 值进行封装。
  • 返回类型: Optional<U>
  • 示例代码:
public static void main(String[] args) {
    // 创建 map 对象
    Map<String, String> userMap = new HashMap<>();
    userMap.put("name", "mydlq");
    userMap.put("sex", "男");

    // 传入 Map 对象参数,获取一个 Optional 对象
    Optional<Map<String, String>> optional1 = Optional.of(userMap);

    // 使用 Optional 的 flatMap 方法,获取 Map 中的 name 属性
    // 然后通过获取的值手动创建一个新的 Optional 对象
    Optional optional2 = optional1.flatMap(value -> Optional.ofNullable(value.get("name")));

    // 获取 Optional 的 value
    System.out.println("获取的 Optional 的值:" + optional2.get());
}

运行代码,可以观察到控制台输出内容如下:

获取的 Optional 的值:mydlq

根据结果观察,可以看到 flatMap 和 map 方法没有什么区别,但是仔细看,代码中调用 flatMap 后,需要手动执行 of 或 ofNullable 方法创建了 Optional 对象。

11、对象方法 filter()

  • 方法作用: 如果有值并且满足断言条件返回包含该值的 Optional,否则返回空 Optional。
  • 方法描述: filter 方法通过传入的限定条件对 Optional 实例的值进行过滤,如果 Optional 值不为空且满足限定条件就返回包含值的 Optional,否则返回空的 Optional。这里设置的限定条件需要使用实现了 Predicate 接口的 lambda 表达式来进行配置。
  • 返回类型: Optional<T>
  • 示例代码:
public static void main(String[] args) {
    // 创建一个测试的 Optional 对象
    Optional<String> optional = Optional.ofNullable("mydlq");
    // 调用 Optional 的 filter 方法,设置一个满足的条件,然后观察获取的 Optional 对象值是否为空
    Optional optional1 =optional.filter((value) -> value.length() > 2);
    System.out.println("Optional 的值不为空::" + optional.isPresent());

    // 调用 Optional 的 filter 方法,设置一个不满足的条件,然后观察获取的 Optional 对象值是否为空
    Optional optional2 =optional.filter((value) -> value.length() <2);
    System.out.println("Optional 的值不为空::" + optional2.isPresent());
}

运行代码,可以观察到控制台输出内容如下:

Optional 的值不为空:true
Optional 的值不为空:false

根据结果可以观察到,可以通过 filter 设置一个条件来判断 Optional 的值,如果满足条件就返回带值的 Optional,否则返回空的 Optional。

4、Optional 常用示例组合

  在介绍一栏中已经说过 Optional 是个容器,它可用保存类型的 T 的值,即使 T 为 null 也可以使用 Optional 存储,这样我就不用显示进行空值检测,防止空指针异常。

  上面也介绍了 Optional 的各种方法,在实际使用中这些方法常常组合使用。且很多方法也常与 Lambda 表达式结合,获取我们想要的结果的值。

下面是常用的示例,可以作为参考:

对集合中的对象属性进行过滤

创建一个 User 对象实体类,里面包含 name 属性:

public class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

创建一个使用 main 方法的类,创建几个 User 对象且设置不同的值,有的对象为 null 有的属性不设置,然后通过 Optional 获取 name 属性值加入集合,进行测试:

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

public class OptionalExample {

    /**
     * 测试的 main 方法
     */
    public static void main(String[] args) {
        // 创建一个测试的用户集合
        List<User> userList = new ArrayList<>();

        // 创建几个测试用户
        User user1 = new User("abc");
        User user2 = new User("efg");
        User user3 = null;

        // 将用户加入集合
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);

        // 创建用于存储姓名的集合
        List<String> nameList = new ArrayList();
        // 循环用户列表获取用户信息,值获取不为空且用户以 a 开头的姓名,
        // 如果不符合条件就设置默认值,最后将符合条件的用户姓名加入姓名集合
        for (User user : userList) {
            nameList.add(Optional.ofNullable(user).map(User::getName).filter(value -> value.startsWith("a")).orElse("未填写"));
        }

        // 输出名字集合中的值
        System.out.println("通过 Optional 过滤的集合输出:");
        nameList.stream().forEach(System.out::println);
    }

}

输出运行结果:

通过 Optional 过滤的集合输出:
abc
未填写
未填写

通过上面,可以观察到,使用 Optional 有时候可以很方便的过滤一些属性,而且它的方法可以通过链式调用,方法间相互组合使用,使我们用少量的代码就能完成复杂的逻辑。

5.相似方法进行对比分析

  可能小伙伴看到这,没用用过的话会觉得orElse()和orElseGet()还有orElseThrow()很相似,map()和flatMap()好相似,哈哈哈不用着急,都是从这一步过来的,我再给大家总结一下不同方法的异同点

orElse()和orElseGet()和orElseThrow()的异同点

方法效果类似,如果对象不为空,则返回对象,如果为空,则返回方法体中的对应参数,所以可以看出这三个方法体中参数是不一样的

  • orElse(T 对象)
  • orElseGet(Supplier < T >对象)
  • orElseThrow(异常)

map()和orElseGet的异同点

  • 方法效果类似,对方法参数进行二次包装,并返回,入参不同
  • map(function函数)
  • flatmap(Optional< function >函数)

具体要怎么用,要根据业务场景以及代码规范来定义,下面可以简单看一下我在实战中怎用使用神奇的Optional

实战场景再现

场景1:

在service层中查询一个对象,返回之后判断是否为空并做处理

//查询一个对象
Member member = memberService.selectByIdNo(request.getCertificateNo());
//使用ofNullable加orElseThrow做判断和操作
Optional.ofNullable(member).orElseThrow(() -> new ServiceException("没有查询的相关数据"));

场景2:

我们可以在dao接口层中定义返回值时就加上Optional 例如:我使用的是jpa,其他也同理

public interface LocationRepository extends JpaRepository<Location, String> {
Optional<Location> findLocationById(String id);
}

然在是Service中

public TerminalVO findById(String id) {
//这个方法在dao层也是用了Optional包装了
        Optional<Terminal> terminalOptional = terminalRepository.findById(id);
        //直接使用isPresent()判断是否为空
        if (terminalOptional.isPresent()) {
        //使用get()方法获取对象值
            Terminal terminal = terminalOptional.get();
            //在实战中,我们已经免去了用set去赋值的繁琐,直接用BeanCopy去赋值
            TerminalVO terminalVO = BeanCopyUtils.copyBean(terminal, TerminalVO.class);
            //调用dao层方法返回包装后的对象
            Optional<Location> location = locationRepository.findLocationById(terminal.getLocationId());
            if (location.isPresent()) {
                terminalVO.setFullName(location.get().getFullName());
            }
            return terminalVO;
        }
        //不要忘记抛出异常
        throw new ServiceException("该终端不存在");
    }

6.Optional使用注意事项

Optional真么好用,真的可以完全替代if判断吗?

我想这肯定是大家使用完之后Optional之后可能会产生的想法,答案是否定的,举一个最简单的栗子:

如果我只想判断对象的某一个变量是否为空并且做出判断呢?

Person person=new Person();
person.setName("");
persion.setAge(2);
//普通判断
if(StringUtils.isNotBlank(person.getName())){
  //名称不为空执行代码块
}
//使用Optional做判断
Optional.ofNullable(person).map(p -> p.getName()).orElse("name为空");

  我觉得这个例子就能很好的说明这个问题,只是一个很简单判断,如果用了Optional我们还需要考虑包装值,考虑代码书写,考虑方法调用,虽然只有一行,但是可读性并不好,如果别的程序员去读,我觉得肯定没有if看的明显。

7.jdk1.9对Optional优化

首先增加了三个方法:or()ifPresentOrElse()stream()

  • or() 与orElse等方法相似,如果对象不为空返回对象,如果为空则返回or()方法中预设的值。
  • ifPresentOrElse() 方法有两个参数:一个 Consumer 和一个 Runnable。如果对象不为空,会执行 Consumer 的动作,否则运行 Runnable。相比ifPresent()多了OrElse判断。
  • stream()将Optional转换成stream,如果有值就返回包含值的stream,如果没值,就返回空的stream。

  因为这个jdk1.9的Optional具体我没有测试,同时也发现有蛮好的文章已经也能让大家明白jdk1.9的option的优化,我就不深入去说了。

原文参考公众号【Java知音】

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 【Java8新特性】不了解Optional类,简历上别说你懂Java8!!

    作者个人研发的在高并发场景下,提供的简单、稳定、可扩展的延迟消息队列框架,具有精准的定时任务和延迟队列处理功能。自开源半年多以来,已成功为十几家中小型企业提供了...

    冰河
  • JAVA8实战 - Optional工具类

    没错,这又是一个新的专栏,JAVA8可以说是JAVA划时代的一个版本,几乎是让JAVA焕发了第三春(第二春在JDK5),当然里面的新特性也是十分重要的,虽然J...

    阿东
  • 如何在 Java8 中风骚走位避开空指针异常

    要说 Java 编程中哪个异常是你印象最深刻的,那 NullPointerException 空指针可以说是臭名昭著的。不要说初级程序员会碰到,即使是中级,专家...

    Java技术江湖
  • 求求你不要在用!=null判空了

    在没有用Optional判空之前,你是否也像下面的代码一样判空呢?如果是,请往下看,Optional 相对传统判空的优势。

    Leetcode名企之路
  • 如何在 Java8 中风骚走位避开空指针异常

    要说 Java 编程中哪个异常是你印象最深刻的,那 NullPointerException 空指针可以说是臭名昭著的。不要说初级程序员会碰到,即使是中级,专家...

    JAVA葵花宝典
  • 还在重复写空指针检查代码?考虑使用 Optional 吧!

    如果要给 Java 所有异常弄个榜单,我会选择将 NullPointerException 放在榜首。这个异常潜伏在代码中,就像个遥控炸弹,不知道什么时候这个按...

    andyxh
  • 探究Java8的Optional 类

    “ 在前面我们已经谈论过Java8的Lambda表达式,方法引用,Stream。除了这些之外Java8中还有一个很重要的知识:Optional ”

    每天学Java
  • Java函数式开发——优雅的Optional空指针处理

    空闲时会抽空学习同在jvm上运行的Groovy和Scala,发现他们对null的处理比早期版本Java慎重很多。在Java8中,Optional为函数式编程的n...

    哲洛不闹
  • Java8之熟透Optional

    在写程序的时候一般都遇到过 NullPointerException,所以经常会对程序进行非空的判断:

    用户1195962
  • Java8新特性之空指针异常的克星Optional类

    版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。 ...

    程序新视界
  • [译]厌倦了NullPointException?Optional拯救你!

    有人说,当你处理过了空指针异常才真正成为一个Java开发者。抛开玩笑话不谈,空指针确实是很多bug的根源。Java SE 8引入了一个新的叫做java.util...

    weishu
  • Java函数式开发——优雅的Optional空指针处理

        在Java江湖流传着这样一个传说:直到真正了解了空指针异常,才能算一名合格的Java开发人员。在我们逼格闪闪的java码字符生涯中,每天都会遇到各种nu...

    随风溜达的向日葵
  • 使用Java8中的Optional类来消除代码中的null检查

    lw900925.github.io/java/java8-optional.html

    JAVA葵花宝典
  • 还在重复写空指针检查代码?考虑使用 Optional 吧!

    如果要给 Java 所有异常弄个榜单,我会选择将 NullPointerException 放在榜首。这个异常潜伏在代码中,就像个遥控炸弹,不知道什么时候这个按...

    纯洁的微笑
  • 还在重复写空指针检查代码?考虑使用 Optional 吧!

    如果要给 Java 所有异常弄个榜单,我会选择将 NullPointerException 放在榜首。这个异常潜伏在代码中,就像个遥控炸弹,不知道什么时候这个按...

    沉默王二
  • 【Java8新特性】知识点总结,你都会了吗?

    作者个人研发的在高并发场景下,提供的简单、稳定、可扩展的延迟消息队列框架,具有精准的定时任务和延迟队列处理功能。自开源半年多以来,已成功为十几家中小型企业提供了...

    冰河
  • Java8 Lambda表达式、Optional类浅析

    Lambda是一个匿名函数,可以将其理解为一段可以传递的代码(将代码像数据一样进行传递)可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,使得java语言...

    Kevin_Zhang
  • Optional 和 Stream

    Optional 不是函数式接口,而是用于防止 NullPointerException 的一个工具类。

    happyJared
  • 在Java中如何优雅地判空

    作为搬砖党的一族们,我们对判空一定再熟悉不过了,不要跟我说你很少进行判空,除非你喜欢 NullPointerException。

    JAVA葵花宝典

扫码关注云+社区

领取腾讯云代金券