Java8新特性-013-Optional 容器类

概述

Optional<T> 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用null 表示一个值不存在，现在Optional 可以更好的表达这个概念。并且可以避免空指针异常。

• 常用方法：
  1.Optional.of(T t) : 创建一个Optional 实例
  2.Optional.empty() : 创建一个空的Optional 实例
  3.Optional.ofNullable(T t):若t 不为null,创建Optional 实例,否则创建空实例
  4.isPresent() : 判断是否包含值
  5.orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
  6.orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回s 获取的值
  7.map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty()
  8.flatMap(Function mapper):与map 类似，要求返回值必须是Optional

测试代码

TestOptional.java

package java8.optional;

import java.util.Optional;

import org.junit.Test;

/** 
* @author 微信公众号：JavaWeb架构师
* @version 创建时间：5 Jan 2018 12:58:39 
*/
public class TestOptional {
    
    /**
     * 
     * Optional概述：
     *  Optional<T> 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，
     *  原来用null 表示一个值不存在，现在Optional 可以更好的表达这个概念。并且
     *  可以避免空指针异常。
     * 方法：
     *  1.Optional.of(T t) : 创建一个Optional 实例
     *  2.Optional.empty() : 创建一个空的Optional 实例
     *  3.Optional.ofNullable(T t):若t 不为null,创建Optional 实例,否则创建空实例
     *  4.isPresent() : 判断是否包含值
     *  5.orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
     *  6.orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回s 获取的值
     *  7.get()：返回对象中包含的值，是空Optional的话，有会异常
     *  8.map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty()
     *  9.flatMap(Function mapper):与map 类似，要求返回值必须是Optional
     */
    
    // 1.Optional.of(T t)：封装非null值
    @Test
    public void test1() {
        // ①.Optional.of(T t)：封装一个Optional实例，其中值t不能为null，否则有NullPointException
        Optional<String> optional = Optional.of(new String("冯强"));
        
        // ②.Optinal.get()：获取其中封装的值
        String name = optional.get();
        
        System.out.println("姓名：" + name);
        /*
         * 结果：
         * 姓名：冯强
         */
    }
    
    // 2.Optional.empty()：封装一个空的Optional实例
    @Test
    public void test2() {
        // ①.Optional.empty()：封装一个空的Optional对象（封装null）
        Optional<Object> empty = Optional.empty();
        
        // ②.isPresent()：判断其中是否包含值
        System.out.println(empty+ ":" + empty.isPresent());
        
        // 封装的空的Optional，调用其中的get()方法会出现NoSuchElementException  
        empty.get();
        /*
         * 结果：
         * Optional.empty:false
         * java.util.NoSuchElementException: No value present
         */
    }
    
    // 3.Optional.ofNullable(T t):非null就和of方法一样，null就和empty()一样
    @Test
    public void test3() {
        // 封装null成一个空的Optional
        Optional<Object> nullable = Optional.ofNullable(null);
        System.out.println(nullable+ ":" + nullable.isPresent());
        
        // 封装一个非null值成Optional
        Optional<String> nullable2 = Optional.ofNullable(new String ("冯强"));
        System.out.println("姓名：" + nullable2.get());
        /*
         * 结果;
         * Optional.empty:false
         * 姓名：冯强
         */
    }
    
    // 4.获取对象中的值
    @Test
    public void test4() {
        Optional<Object> ofNullable = Optional.ofNullable(null);
        
        // ①.orElse(T t) : 如果包含值，那返回值；否则返回替代值-t
        Object orElse = ofNullable.orElse(new String("冯强"));
        System.out.println("姓名：" + orElse);
        
        // ②.orElseGet(Supplier s) :如果包含值，那返回值；否则返回s 获取的值
        Object orElseGet = ofNullable.orElseGet(() -> new String("冯强"));
        System.out.println("姓名：" + orElseGet);
        
        // ③.get()：返回对象中包含的值，是空Optional的话，有会异常
        System.out.println("姓名：" + ofNullable.get());
        /*
         * 结果：
         * 姓名：冯强
         * 姓名：冯强
         * java.util.NoSuchElementException: No value present
         */
    }
    
    // 5.map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty()
    @Test
    public void test5() {
        Optional<String> ofNullable = Optional.ofNullable(new String("冯强"));
        
        // 把原有值处理成另外一个值(原有值类型及其子类)，封装在Optional中返回(会自动的把返回值封装在Optional中)
        Optional<String> map = ofNullable.map((e) -> "帅哥" );
        
        System.out.println(map.orElse("空的"));
        /*
         * 结果：
         * 帅哥
         */
    }
    
    // 6.flatMap(Function mapper):与map 类似，要求返回值必须是Optional
    @Test
    public void test6() {
        Optional<Object> ofNullable = Optional.ofNullable("ssd");
        
        // 必须手动的把返回值封装在Optional中
        Optional<String> flatMap = ofNullable.flatMap((e) -> Optional.ofNullable(new String("冯强")));
        System.out.println(flatMap);
        /*
         * 结果：
         * Optional[冯强]
         */
    }
}

微信公众号：JavaWeb架构师

---

其它

• 源码下载

关注下方公众号，回复：Java8.code

• 欢迎加入交流群：451826376

• 更多信息：www.itcourse.top

完整教程PDF版本下载