Java8中的新特性Optional

Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
Optional 类的引入很好的解决空指针异常。

package com.demo.optional;

import lombok.extern.slf4j.Slf4j;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.Optional;

@Slf4j

@RunWith(SpringRunner.class)

@SpringBootTest

public class TestOptional {

    @Test

    public void testOptional() {

        TestOptional test = new TestOptional();

        Integer value1 = null;

        Integer value2 = new Integer(10);

        // Optional.ofNullable - 允许传递为 null 参数

        Optional<Integer> a = Optional.ofNullable(value1);

        // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException

        Optional<Integer> b = Optional.of(value2);

        log.info("{}", test.sum(a, b));

    }

    public Integer sum(Optional<Integer> a, Optional<Integer> b) {

        // Optional.isPresent - 判断值是否存在

        log.info("第一个参数值存在: {}", a.isPresent());

        log.info("第二个参数值存在: {}", b.isPresent());

        // Optional.orElse - 如果值存在返回它，否则返回默认值

        Integer value1 = a.orElse(new Integer(0));

        //Optional.get - 获取值，值需要存在

        Integer value2 = b.get();

        return value1 + value2;

    }

}

在Java8之前，任何访问对象方法或属性的调用都可能导致 NullPointerException。如果需要确保不触发异常，就得在访问每一个值之前对其进行明确地检查。

1、明确对象不为null的时候使用of()。如果对象即可能是null也可能是非null，你就应该使用ofNullable()方法。

package com.demo.optional;

import com.demo.optional.domain.User;

import lombok.extern.slf4j.Slf4j;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.NoSuchElementException;

import java.util.Optional;

import static junit.framework.TestCase.assertTrue;

import static org.junit.Assert.assertEquals;

@Slf4j

@RunWith(SpringRunner.class)

@SpringBootTest

public class OptionalTest {

    @Test(expected = NoSuchElementException.class)

    public void whenCreateEmptyOptionalThenNull() {

        Optional<User> emptyOpt = Optional.empty();

        emptyOpt.get();

    }

    //明确对象不为null的时候使用of()

    @Test(expected = NullPointerException.class)

    public void whenCreateOfEmptyOptionalThenNullPointerException() {

        User user = null;

        Optional<User> opt = Optional.of(user);

    }

    //如果对象即可能是null也可能是非null，你就应该使用ofNullable()方法

    @Test

    public void whenCreateOfEmptyOptionalThenNoNullPointerException() {

        User user = null;

        Optional<User> opt = Optional.ofNullable(user);

    }

}

2、访问Optional对象的值

package com.demo.optional;

import com.demo.optional.domain.User;

import lombok.extern.slf4j.Slf4j;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.NoSuchElementException;

import java.util.Optional;

import static junit.framework.TestCase.assertTrue;

import static org.junit.Assert.assertEquals;

@Slf4j

@RunWith(SpringRunner.class)

@SpringBootTest

public class OptionalTest {

    //从Optional实例中取回实际值对象的方法之一是使用get()方法

    @Test

    public void whenCreateOfNullableOptionalThenOk() {

        String name = "John";

        Optional<String> opt = Optional.ofNullable(name);

        assertEquals("John", opt.get());

    }

    //get()方法会在值为null的时候抛出异常。要避免异常，你可以选择首先验证是否有值

    @Test

    public void whenCheckIsPresentThenOk() {

        User user = new User("john@gmail.com", "1234");

        Optional<User> opt = Optional.ofNullable(user);

        assertTrue(opt.isPresent());

        assertEquals(user.getEmail(), opt.get().getEmail());

    }

    //检查是否有值的另一个选择是ifPresent()方法。该方法除了执行检查，还接受一个Consumer(消费者)参数，如果对象不是空的，就对执行传入的Lambda表达式

    @Test

    public void whenCheckIfPresentThenOk() {

        User user = new User("john@gmail.com", "1234");

        Optional<User> opt = Optional.ofNullable(user);

        opt.ifPresent(u -> assertEquals(user.getEmail(), u.getEmail()));

    }

}

3、返回默认值：Optional类提供了API用以返回对象值，或者在对象为空的时候返回默认值。

package com.demo.optional;

import com.demo.optional.domain.User;

import lombok.extern.slf4j.Slf4j;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.Optional;

import static org.junit.Assert.assertEquals;

@Slf4j

@RunWith(SpringRunner.class)

@SpringBootTest

public class OptionalTest {

    //orElse()如果有值则返回该值，否则返回传递给它的参数值

    @Test

    public void whenEmptyValueThenReturnDefault() {

        User user = null;

        User user2 = new User("anna@gmail.com", "1234");

        User result = Optional.ofNullable(user).orElse(user2);

        assertEquals(user2.getEmail(), result.getEmail());

    }

    //如果对象的初始值不是 null，那么默认值会被忽略

    @Test

    public void whenValueNotNullThenIgnoreDefault() {

        User user = new User("john@gmail.com", "1234");

        User user2 = new User("anna@gmail.com", "1234");

        User result = Optional.ofNullable(user).orElse(user2);

        assertEquals("john@gmail.com", result.getEmail());

    }

    //orElseGet()方法会在有值的时候返回值，如果没有值，它会执行作为参数传入的Supplier(供应者)函数式接口，并将返回其执行结果

    @Test

    public void testOrElseGet() {

        User user = new User("john@gmail.com", "1234");

        User user2 = new User("anna@gmail.com", "1234");

        User result = Optional.ofNullable(user).orElseGet(() -> user2);

        assertEquals("john@gmail.com", result.getEmail());

    }

}

4、orElse()和orElseGet()的不同之处

package com.demo.optional;

import com.demo.optional.domain.User;

import jdk.nashorn.internal.runtime.regexp.joni.constants.OPCode;

import lombok.extern.slf4j.Slf4j;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.NoSuchElementException;

import java.util.Optional;

import static junit.framework.TestCase.assertTrue;

import static org.junit.Assert.assertEquals;

@Slf4j

@RunWith(SpringRunner.class)

@SpringBootTest

public class OptionalTest {

    /*

     * 对象为空时，两种方法都调用了createNewUser()方法，这个方法会记录一个消息并返回User对象。

     * 当对象为空而返回默认对象时，行为并无差异。

     */

    @Test

    public void givenEmptyValueWhenCompareThenOk() {

        User user = null;

        log.info("Using orElse");

        User result = Optional.ofNullable(user).orElse(createNewUser());

        log.info("User orElseGet");

        User result2 = Optional.ofNullable(user).orElseGet(() -> createNewUser());

    }

    /*

     * 两个Optional对象都包含非空值，两个方法都会返回对应的非空值。orElse()方法仍然创建了User对象。与之相反,orElseGet()方法不创建 User 对象。

     * 在执行较密集的调用时，比如调用Web服务或数据查询，这个差异会对性能产生重大影响。

     */

    @Test

    public void givenPresentValueWhenCompareThenOk() {

        User user = new User("john@gmail.com", "1234");

        log.info("Using orElse");

        User result = Optional.ofNullable(user).orElse(createNewUser());

        log.info("Using orElseGet");

        User result2 = Optional.ofNullable(user).orElseGet(() -> createNewUser());

    }

    private User createNewUser() {

        log.info("Creating New User");

        return new User("extra@gmail.com", "1234");

    }

}

5、返回异常

除了orElse()和orElseGet()方法，Optional还定义了orElseThrow(),它会在对象为空的时候抛出异常，而不是返回备选的值。

package com.demo.optional;

import com.demo.optional.domain.User;

import jdk.nashorn.internal.runtime.regexp.joni.constants.OPCode;

import lombok.extern.slf4j.Slf4j;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.NoSuchElementException;

import java.util.Optional;

import static junit.framework.TestCase.assertTrue;

import static org.junit.Assert.assertEquals;

@Slf4j

@RunWith(SpringRunner.class)

@SpringBootTest

public class OptionalTest {

    /*

     * orElseThrow()方法有更丰富的语义，可以决定抛出什么样的异常，而不总是抛出 NullPointerException。

     * 如果 user 值为 null，会抛出 IllegalArgumentException。

     */

    @Test(expected = IllegalArgumentException.class)

    public void whenThrowExceptionThenOk() {

        User user = null;

        User result = Optional.ofNullable(user)

                .orElseThrow(() -> new IllegalArgumentException());

    }

}

6、转换值

package com.demo.optional;

import com.demo.optional.domain.User;

import lombok.extern.slf4j.Slf4j;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.Optional;

import static org.junit.Assert.assertEquals;

@Slf4j

@RunWith(SpringRunner.class)

@SpringBootTest

public class OptionalTest {

    //如果创建的Optional中的值存在，对该值执行提供的Function函数调用

    @Test

    public void whenMapThenOk() {

        User user = new User("anna@gmail.com", "1234");

        String email = Optional.ofNullable(user)

                .map(u -> u.getEmail()).orElse("default@gmail.com");

        assertEquals(email, user.getEmail());

    }

    //如果创建的Optional中的值存在，就对该值执行提供的Function函数调用，返回一个Optional类型的值，否则就返回一个空的Optional对象

    @Test

    public void whenFlatMapThenOk() {

        User user = new User("anna@gmail.com", "1234");

        user.setPosition("Developer");

        String position = Optional.ofNullable(user)

                .flatMap(u -> u.getPosition()).orElse("default");

        assertEquals(position, user.getPosition().get());

    }

}

7、过滤值

filter()接受一个Predicate参数，返回测试结果为true的值。如果测试结果为false，会返回一个空的Optional。

package com.demo.optional;

import com.demo.optional.domain.User;

import lombok.extern.slf4j.Slf4j;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.Optional;

import static junit.framework.TestCase.assertTrue;

@Slf4j

@RunWith(SpringRunner.class)

@SpringBootTest

public class OptionalTest {

    @Test

    public void whenFilterThenOk() {

        User user = new User("anna@gmail.com", "1234");

        Optional<User> result = Optional.ofNullable(user)

                .filter(u -> u.getEmail() != null && u.getEmail().contains("@"));

        assertTrue(result.isPresent());

    }

}

8、Optional类的链式方法

为了更充分的使用Optional，你可以链接组合其大部分方法，因为它们都返回相同类似的对象。

package com.demo.optional;

import com.demo.optional.domain.Address;

import com.demo.optional.domain.Country;

import com.demo.optional.domain.User;

import lombok.extern.slf4j.Slf4j;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.Optional;

import static org.junit.Assert.assertEquals;

@Slf4j

@RunWith(SpringRunner.class)

@SpringBootTest

public class OptionalTest {

    @Test

    public void whenChainingThenOk() {

        User user = new User("anna@gmail.com", "1234");

        String result = Optional.ofNullable(user)

                .flatMap(u -> u.getAddress())

                .flatMap(a -> a.getCountry())

                .map(c -> c.getIsocode())

                .orElse("default");

        String res = Optional.ofNullable(user)

                .flatMap(User::getAddress)

                .flatMap(Address::getCountry)

                .map(Country::getIsocode)

                .orElse("default");

        assertEquals(result, "default");

        assertEquals(res, "default");

    }

}

实体类User：

package com.demo.optional.domain;

import lombok.Data;

import java.util.Optional;

@Data

public class User {

    private Integer id;

    private String email;

    private String number;

    private String position;

    private Address address;

    public Optional<Address> getAddress() {

        return Optional.ofNullable(address);

    }

    public Optional<String> getPosition() {

        return Optional.ofNullable(position);

    }

    public User(String email, String number) {

        this.email = email;

        this.number = number;

    }

}

实体类Address:

package com.demo.optional.domain;

import lombok.Data;

import java.util.Optional;

@Data

public class Address {

    private Country country;

    public Optional<Country> getCountry() {

        return Optional.ofNullable(country);

    }

}

实体类Country:

package com.demo.optional.domain;

import lombok.Data;

@Data

public class Country {

    private Integer id;

    private String isocode;

}

9、Java9增强

Java9为Optional类添加了三个方法：or()、ifPresentOrElse() 和 stream()。
or()方法与orElse()和orElseGet()类似，它们都在对象为空的时候提供了替代情况。
or()的返回值是由Supplier参数产生的另一个Optional对象。如果对象包含值，则Lambda表达式不会执行。

package com.demo.optional;

import com.demo.optional.domain.User;

import lombok.extern.slf4j.Slf4j;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.Optional;

import static org.junit.Assert.assertEquals;

@Slf4j

@RunWith(SpringRunner.class)

@SpringBootTest

public class OptionalTest {

    @Test

    public void whenEmptyOptionalThenGetValueFromOr() {

        User user=null;

        User result = Optional.ofNullable(user)

                .or( () -> Optional.of(new User("default","1234"))).get();

        assertEquals(result.getEmail(), "default");

    }

}

ifPresentOrElse()方法需要两个参数:一个Consumer和一个Runnable。如果对象包含值，会执行Consumer的动作，否则运行Runnable。

如果想在有值的时候执行某个动作，或者只是跟踪是否定义了某个值，那么这个方法非常有用。

package com.demo.optional;

import com.demo.optional.domain.User;

import lombok.extern.slf4j.Slf4j;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.Optional;

@Slf4j

@RunWith(SpringRunner.class)

@SpringBootTest

public class OptionalTest {

    @Test

    public void testIfPresentOrElse() {

        User user = new User("anna@gmail.com", "1234");

        Optional.ofNullable(user).ifPresentOrElse(u -> log.info("User is:" + u.getEmail()),

                () -> log.info("User not found"));

    }

}

stream()方法把实例转换为Stream对象。Stream的使用带来了其filter()、map()和collect()接口，以获取List。

package com.demo.optional;

import com.demo.optional.domain.Address;

import com.demo.optional.domain.Country;

import com.demo.optional.domain.User;

import lombok.extern.slf4j.Slf4j;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

import java.util.NoSuchElementException;

import java.util.Optional;

import java.util.stream.Collectors;

import static junit.framework.TestCase.assertTrue;

import static org.junit.Assert.assertEquals;

@Slf4j

@RunWith(SpringRunner.class)

@SpringBootTest

public class OptionalTest {

    @Test

    public void testStream() {

        User user = new User("john@gmail.com", "1234");

        List<String> emails = Optional.ofNullable(user)

                .stream()

                .filter(u -> u.getEmail() != null && u.getEmail().contains("@"))

                .map(u -> u.getEmail())

                .collect(Collectors.toList());

        assertTrue(emails.size() == 1);

        assertEquals(emails.get(0), user.getEmail());

    }

}

Optional不是Serializable。因此，它不应该用作类的字段。
如果需要序列化的对象包含Optional值，Jackson库支持把Optional当作普通对象。也就是说，Jackson会把空对象看作null，而有值的对象则把其值看作对应域的值。这个功能在jackson-modules-java8项目中。

参考：

https://www.cnblogs.com/zhangboyu/p/7580262.html

https://blog.csdn.net/zknxx/article/details/78586799

Java8中的新特性Optional的更多相关文章

Java8 的一些新特性总结
目前Java8已经发布很多个版本了,对于Java8中的新特性虽然有各位大神进行jdk8的英文特性文档翻译,但都太官方化语言,对照几篇翻译本人对新特性文档做一下总结,以帮助我和各位不了解Java8新特性 ...
JAVA8新特性Optional，非空判断
Optional java 的 NPE(Null Pointer Exception)所谓的空指针异常搞的头昏脑涨, 有大佬说过 "防止 NPE,是程序员的基本修养." 但是修养归 ...
Java基础学习总结（33）——Java8 十大新特性详解
Java8 十大新特性详解本教程将Java8的新特新逐一列出,并将使用简单的代码示例来指导你如何使用默认接口方法,lambda表达式,方法引用以及多重Annotation,之后你将会学到最新的API ...
常见面试题：java8有什么新特性？
常见面试题:java8有什么新特性? 主要有以下这些新特性: lambda 表达式,经常配合函数式接口使用,可以有效减少代码量 Runnable 是一个函数式接口,下面展示了创建线程三种写法,显然最后 ...
使用示例带你提前了解 Java 9 中的新特性
使用示例带你提前了解 Java 9 中的新特性转载来源:https://juejin.im/post/58c5e402128fe100603cc194 英文出处:https://www.journa ...
JDK1.8新特性——Optional类
JDK1.8新特性——Optional类摘要:本文主要学习了JDK1.8新增加的Optional类. 部分内容来自以下博客: https://www.cnblogs.com/1ning/p/9140 ...
【Java8新特性】一张图带你领略Java8有哪些新特性
写在前面很多小伙伴留言说,冰河你能不能写一些关于Java8的文章呢,看书看不下去,看视频进度太慢.好吧,看到不少读者对Java8还是比较陌生的,那我就写一些关于Java8的文章吧,希望对大家有所帮助 ...
ASP.NET 5与MVC 6中的新特性
差点忘了提一句,MVC 6中默认的渲染引擎Razor也将得到更新,以支持C# 6中的新语法.而Razor中的新特性还不只这一点. 在某些情况下,直接在Web页面中嵌入某些JSON数据的方式可能比向服务 ...
Webpack 3 中的新特性
本文简短地分享下最新发布的 Webpack 3 中的新特性,供大家参考. 1. Webpack 3 的新特性 6 月 20 日,Webpack 发布了最新的 3.0 版本,并在 Medium 发布了公 ...

随机推荐

HihoCoder1656 : 前缀后缀查询（[Offer收割]编程练习赛39）（字典树+小技巧）
描述给定一个包含N个单词的字典:{W1, W2, W3, ... WN},其中第i个单词Wi有具有一个权值Vi. 现在小Hi要进行M次查询,每次查询包含一个前缀字符串Pi和一个后缀字符串Si.他希望 ...
win8、win10下卸载程序报错误2502、2503的解决办法
首先打开任务管理器,可以通过右键点击桌面上的任务栏打开任务管理器,也可以通过同时按下键盘上的Ctrl+Alt+Delete键打开任务管理器. 打开任务管理器后,切换到“详细信息”选项卡,找到explo ...
java-03 方法
#############练习###################### 1.键盘录入乘法表 import java.util.Scanner; public class PrintNN { pub ...
【Python】numpy 数组拼接、分割
摘自https://docs.scipy.org 1.The Basics 1.1 numpy 数组基础 NumPy’s array class is called ndarray. ndarray. ...
ubuntu在recovery模式下更改用户密码
http://www.jb51.net/os/Ubuntu/164636.html 1, restart 2, Hold down shift key / press and hold 3, sele ...
WPF系列学习之三（路由事件）
路由事件实际上以一上列三种方式出现. 1.与普通的.net事件类似的直接路由事件.它们起源于一个元素,并且不传递给其他元素.例如:MouseEnter事件. 2.在包含层次中向上传递的冒 ...
html中连续点击某个标签会出现蓝色的解决方法
给标签加上下面的属性就可以了,也可以把这些属性建立一个class名,谁需要的时候加上也ok -moz-user-select: none; /*mozilar*/ -webkit-user-selec ...
nodejs链接mysql
使用mysql连接池:1.安装mysql支持npm install mysql 2.安装node.js的mysqlpool模块npm install -g node-mysql //-g表全局 3.直 ...
POJ-3050
Hopscotch Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 4385 Accepted: 2924 Descrip ...
linux 下jansson安装和使用
1.安装jansson ./configure make make install 2.生成帮助文档 cd doc make html 编译安装doc时提示 spinx-build not a com ...

Java8中的新特性Optional

Java8中的新特性Optional的更多相关文章

随机推荐

热门专题