潍坊新闻综合频道报道：Java 8 Optional 良心指南，建议收藏

想学习，永远都不晚，尤其是针对 Java 8 里面{的}好东西，Optional 就是其中之一，该类提供了一种用于表示可选值而非空引用{的}类级别解决方案。作为一名 Java 程序员，我真{的}是烦透了 NullPointerException（NPE），尽管和它熟得就像一位老朋友，知道它也是迫不得已——程序正在使用一个对象却发现这个对象{的}值为 null，于是 Java 虚拟机就怒发冲冠地把它抛了出来当做替罪羊。

当然了，我们程序员是富有责任心{的}，不会坐视不管，于是就有了大量{的} null 值检查。尽管有时候这种检查完全没有必要，但我们已经习惯了例行公事。终于，Java 8 看不下去了，就引入了 Optional，以便我们编写{的}代码不再那么刻薄呆板。

01、没有 Optional 会有什么问题

我们来模拟一个实际{的}应用场景。小王第一天上班，领导老马就给他安排了一个任务，要他从数据库中根据会员 ID 拉取一个会员{的}姓名，然后将姓名打印到控制台。虽然是新来{的}，但这个任务难不倒小王，于是他花了 10 （分钟写下了这段代码）：

public class WithoutOptionalDemo {
    class Member {
        private String name;

        public String getName() {
            return name;
        }

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

    public static void main(String[] args) {
        Member mem = getMemberByIdFromDB();
        if (mem != null) {
            System.out.println(mem.getName());
        }
    }

    public static Member getMemberByIdFromDB() {
        // 当前 ID {的}会员不存在
        return null;
    }
}

由于当前 ID {的}会员不存在，所以 getMemberByIdFromDB() 方法返回了 null 来作为没有获取到该会员{的}结果，那就意味着在打印会员姓名{的}时候要先对 mem 判空，否则就会抛出 NPE 异常，不信？让小王把 if (mem != null) 去掉试试，控制台立马打印错误堆栈给你颜色看看。

Exception in thread "main" java.lang.NullPointerException
    at com.cmower.dzone.optional.WithoutOptionalDemo.main(WithoutOptionalDemo.java:24)

02、Optional （是如何解决这个问题{的}）

小王把代码提交后，就兴高采烈地去找老马要新{的}任务了。“本着虚心学习{的}态度”，小王请求老马看一下自己{的}代码，【于是老王就告诉他应该尝试一下】 Optional，可以避免没有必要{的} null 值检查。现在，让我们来看看小王是如何 通过[ Optional 来解决上述问题{的}。

public class OptionalDemo {
    public static void main(String[] args) {
        Optional<Member> optional = getMemberByIdFromDB();
        optional.ifPresent(mem -> {
            System.out.println("会员姓名是：" + mem.getName());
        });
    }

    public static Optional<Member> getMemberByIdFromDB() {
        boolean hasName = true;
        if (hasName) {
            return Optional.of(new Member("沉默王二"));
        }
        return Optional.empty();
    }
}
class Member {
    private String name;

    public String getName() {
        return name;
    }

    // getter / setter
}

getMemberByIdFromDB() 方法返回了 Optional<Member> 作为结果，这样就表明 Member 可能存在，也可能不存在，这时候就可以在 Optional {的} ifPresent() 方法中使用 Lambda 表达式来直接打印结果。

Optional 之所以可以解决 NPE {的}问题，是因为它明确{的}告诉我们，不需要对它进行判空。它就好像十字路口{的}路标，明确地告诉你该往哪走。

03、创建 Optional 对象

1）「【可以使用静态方法】」 empty() 创建一个空{的} Optional 对象

Optional<String> empty = Optional.empty();
System.out.println(empty); // 【输出】：Optional.empty

2）「【可以使用静态方法】」 of() 创建一个非空{的} Optional 对象

Optional<String> opt = Optional.of("沉默王二");
System.out.println(opt); // 【输出】：Optional[沉默王二]

当然了，传递给 of() 方法{的}参数必须是非空{的}，也就是说不能为 null，“否则仍然会抛出” NullPointerException。

String name = null;
Optional<String> optnull = Optional.of(name);

3）「【可以使用静态方法】」 ofNullable() 创建一个即可空又可非空{的} Optional 对象

String name = null;
Optional<String> optOrNull = Optional.ofNullable(name);
System.out.println(optOrNull); // 【输出】：Optional.empty

ofNullable() 方法内部有一个三元表达式，（如果）为参数为 null，【则返回私有常量】 EMPTY；否则使用 new 关键字创建了一个新{的} Optional 对象——不会再抛出 NPE 异常了。

04、判断值是否存在

「可以 通过[方法」 isPresent() 判断一个 Optional 对象是否存在，（如果）存在，{该方法返回} true，否则返回 false——‘取代了’ obj != null {的}判断。

Optional<String> opt = Optional.of("沉默王二");
System.out.println(opt.isPresent()); // 【输出】：true

Optional<String> optOrNull = Optional.ofNullable(null);
System.out.println(opt.isPresent()); // 【输出】：false

Java 11 后还「可以 通过[方法」 isEmpty() 判断与 isPresent() 相反{的}结果。

Optional<String> opt = Optional.of("沉默王二");
System.out.println(opt.isPresent()); // 【输出】：false

Optional<String> optOrNull = Optional.ofNullable(null);
System.out.println(opt.isPresent()); // 【输出】：true

05、非空表达式

Optional 类有一个非常现代化{的}方法——ifPresent()，允许我们使用函数式编程{的}方式执行一些代码，因此，我把它称为非空表达式。（如果）没有该方法{的}话，我们通常需要先 通过[ isPresent() 方法对 Optional 对象进行判空后再执行相应{的}代码：

Optional<String> optOrNull = Optional.ofNullable(null);
if (optOrNull.isPresent()) {
    System.out.println(optOrNull.get().length());
}

有了 ifPresent() 之后，情况就完全不同了，可以直接将 Lambda 表达式传递给该方法，代码更加简洁，更加直观。

Optional<String> opt = Optional.of("沉默王二");
opt.ifPresent(str -> System.out.println(str.length()));

Java 9 后还「可以 通过[方法」 ifPresentOrElse(action, emptyAction) 执行两种结果，非空时执行 action，空时执行 emptyAction。

Optional<String> opt = Optional.of("沉默王二");
opt.ifPresentOrElse(str -> System.out.println(str.length()), () -> System.out.println("为空"));

06、设置（获取）默认值

有时候，我们在创建（获取） Optional 对象{的}时候，需要一个默认值，orElse() 和 orElseGet() {方法就派上用}场了。

orElse() 方法用于返回包裹在 Optional 对象中{的}值，（如果）该值不为 null，则返回；否则返回默认值。该方法{的}参数类型和值得类型一致。

String nullName = null;
String name = Optional.ofNullable(nullName).orElse("沉默王二");
System.out.println(name); // 【输出】：沉默王二

orElseGet() 方法与 orElse() 方法类似，但参数类型不同。（如果） Optional 对象中{的}值为 null，则执行参数中{的}函数。

String nullName = null;
String name = Optional.ofNullable(nullName).orElseGet(()->"沉默王二");
System.out.println(name); // 【输出】：沉默王二

从【输出】结果以及代码{的}形式上来看，这两个方法极其相似，这不免引起我们{的}怀疑，Java 类库{的}设计者有必要这样做吗？

假设现在有这样一个获取默认值{的}方法，很传统{的}方式。

public static String getDefaultValue() {
    System.out.println("getDefaultValue");
    return "沉默王二";
}

然后， 通过[ orElse() 方法和 orElseGet() 方法分别调用 getDefaultValue() 方法返回默认值。

public static void main(String[] args) {
    String name = null;
    System.out.println("orElse");
    String name2 = Optional.ofNullable(name).orElse(getDefaultValue());

    System.out.println("orElseGet");
    String name3 = Optional.ofNullable(name).orElseGet(OrElseOptionalDemo::getDefaultValue);
}

注：类名 :: 方法名是 Java 8 引入{的}语法，方法名后面是没有 () {的}，『表明该方法并不一定会被调用』。

【输出】结果如下所示：

orElse
getDefaultValue

orElseGet
getDefaultValue

【输出】结果是相似{的}，没什么太大{的}不同，这是在 Optional 对象{的}值为 null {的}情况下。假如 Optional 对象{的}值不为 null 呢？

public static void main(String[] args) {
    String name = "沉默王三";
    System.out.println("orElse");
    String name2 = Optional.ofNullable(name).orElse(getDefaultValue());

    System.out.println("orElseGet");
    String name3 = Optional.ofNullable(name).orElseGet(OrElseOptionalDemo::getDefaultValue);
}

【输出】结果如下所示：

orElse
getDefaultValue
orElseGet

咦，orElseGet() 没有去调用 getDefaultValue()。哪个方法{的}性能更佳，你明白了吧？

07、获取值

直观从语义上来看，get() 方法才是最正宗{的}获取 Optional 对象值{的}方法，但很遗憾，该方法是有缺陷{的}，因为假如 Optional 对象{的}值为 null，【该方法会抛出】 NoSuchElementException 异常。这完全与我们使用 Optional 类{的}初衷相悖。

public class GetOptionalDemo {
    public static void main(String[] args) {
        String name = null;
        Optional<String> optOrNull = Optional.ofNullable(name);
        System.out.println(optOrNull.get());
    }
}

这段程序在运行时会抛出异常：

Exception in thread "main" java.util.NoSuchElementException: No value present
    at java.base/java.util.Optional.get(Optional.java:141)
    at com.cmower.dzone.optional.GetOptionalDemo.main(GetOptionalDemo.java:9)

尽管抛出{的}异常是 NoSuchElementException 而不是 NPE，但在我们看来，显然是在“〖五十步笑百步〗”。建议 orElseGet() 方法获取 Optional 对象{的}值。

08、过滤值

小王 通过[ Optional 类对之前{的}代码进行了升级，完成后又兴高采烈地跑去找老马要任务了。老马觉得这小伙子不错，头脑灵活，又干活积极，很值得培养，就又交给了小王一个新{的}任务：用户注册时对密码{的}长度进行检查。

<小王拿到任务后>，乐开了花，因为他刚要学习 Optional 类{的} filter() 方法，这就派上了用场。

public class FilterOptionalDemo {
    public static void main(String[] args) {
        String password = "12345";
        Optional<String> opt = Optional.ofNullable(password);
        System.out.println(opt.filter(pwd -> pwd.length() > 6).isPresent());
    }
}

filter() 方法{的}参数类型为 Predicate（Java 8 新增{的}一个函数式接口），也就是说可以将一个 Lambda 表达式传递给该方法作为条件，（如果）表达式{的}结果为 false，则返回一个 EMPTY {的} Optional 对象，否则返回过滤后{的} Optional 对象。

在上例中，由于 password {的}长度为 5 ，所以程序【输出】{的}结果为 false。假设密码{的}长度要求在 6 到 10 位之间，那么还可以再追加一个条件。来看小王增加难度后{的}代码。

Predicate<String> len6 = pwd -> pwd.length() > 6;
Predicate<String> len10 = pwd -> pwd.length() < 10;

password = "1234567";
opt = Optional.ofNullable(password);
boolean result = opt.filter(len6.and(len10)).isPresent();
System.out.println(result);

这次程序【输出】{的}结果为 true，因为密码变成了 7 位，在 6 到 10 位之间。想象一下，假如小王使用 if-else 来完成这个任务，「代码该有多冗长」。

09、转换值

小王检查完了密码{的}长度，仍然觉得不够尽兴，觉得要对密码{的}强度也进行检查，比如说密码不能是“password”，这样{的}密码太弱了。于是他又开始研究起了 map() 方法，该方法可以按照一定{的}规则将原有 Optional 对象转换为一个新{的} Optional 对象，原有{的} Optional 对象不会更改。

先来看小王写{的}一个简单{的}例子：

public class OptionalMapDemo {
    public static void main(String[] args) {
        String name = "沉默王二";
        Optional<String> nameOptional = Optional.of(name);
        Optional<Integer> intOpt = nameOptional
                .map(String::length);

        System.out.println( intOpt.orElse(0));
    }
}

在上面这个例子中，map() 方法{的}参数 String::length，（意味着要） 将原有{的}字符串类型{的} Optional 按照字符串长度重新生成一个新{的} Optional 对象，类型为 Integer。

搞清楚了 map() 方法{的}基本用法后，小王决定把 map() 方法与 filter() 方法结合起来用，前者用于将密码转化为小写，后者用于判断长度以及是否是“password”。

public class OptionalMapFilterDemo {
    public static void main(String[] args) {
        String password = "password";
        Optional<String>  opt = Optional.ofNullable(password);

        Predicate<String> len6 = pwd -> pwd.length() > 6;
        Predicate<String> len10 = pwd -> pwd.length() < 10;
        Predicate<String> eq = pwd -> pwd.equals("password");

        boolean result = opt.map(String::toLowerCase).filter(len6.and(len10 ).and(eq)).isPresent();
        System.out.println(result);
    }
}

好了，我亲爱{的}读者朋友，以上就是本文{的}全部内容了——可以说是史上最佳 Optional 指南了，能看到这里{的}都是最优秀{的}程序员，二哥必须要伸出大拇指为你点个赞。

（如果）觉得文章对你有点帮助，请微信搜索「 沉默王二 」第一时间阅读，回复【666】【1024】更有我为你精心准备{的} 500G 《高清教学》视频（<已分门别类>），以及大厂技术牛人整理{的}面经一份，本文源码已收录在码云，传送门~

,

诚信在线

诚信在线（www.wankeeshoes.com）现已开放诚信在线手机版下载。游戏公平、公开、公正,用实力赢取信誉。