前言

函数式的编程可以极大的简化逻辑代码的编写，虽然是一种语法糖，但是好用就是好用。
Optional 这个功能可以用来防止null值给程序带来的异常，提供的API也可以用来简化逻辑代码的编码，简化if-else的编写。

写法比较

常规代码写法

一般写一个业务逻辑时，业务代码需要加很多判断，保证程序的健状性。

1
2
3
4
5
6
7
8
9
10
11
12
13
public void test() {
  User user = userService.getUser();
  if (user != null) {
    String userName = user.getUserName();
    if (userName != null) {
      return userName.toUpperCase();
    } else {
      return null;
    }
  } else {
    return null;
  }
}

改进后

可以看到，改进后的写法，判空这种操作，直接交给Optional去操作。
解释下面的意思：

  1. Optional.ofNullable(user)，接收 user 这个数据，可以允许为null
  2. null值是不会被 map 操作的，直接忽略
  3. orElse，如果 user == null，才会进这个逻辑。
    整个流程就等价于改进前的逻辑。
1
2
3
4
5
6
7
public void test() {
  User user = userService.getUser();
  return Optional.ofNullable(user)
          .map(User::getUserName)
          .map(String::toUpperCase)
          .orElse(User::new);
}

简单的if-else

调整测试数test就可以看到不同的效果。
记住这个固定的if-else套路。

1
2
3
4
5
6
7
8
  public static void test1() {
//    String test = "test123";
    String test = null;
    String newValue = Optional
            .ofNullable(test)
            .orElse("newValue");
    System.out.println(newValue);
  }

这个示例多加了一个filter，相当于在if()的中插号里写复杂判断逻辑。

1
2
3
4
5
6
7
8
9
  public static void test2() {
    String test = "test123";
//    String test = "test456";
    String newValue = Optional
            .ofNullable(test)
            .filter(str-> str.equals("test456"))
            .orElse("newValue");
    System.out.println(newValue);
  }

等价if-else写法：

1
2
3
4
5
6
7
8
9
  public static void test2() {
    String test = "test123";
//    String test = "test456";
    if (test != null && test.equals("test456")) {
      System.out.println(test); 
    } else {
      System.out.println("newValue");
    }
  }

isPresent() 使用

isPresent 返回boolean，直觉上应该用if-else来判断一下。但是回头想想，如果需要用if-else来判断，直接用if-else来写不完了，干嘛还使用Optional包一层，多此一举。

反面示例

1
2
3
4
5
6
7
8
public String getName(User user){
  Optional<User> u = Optional.ofNullable(user);
  if(!u.isPresent()){
    return "Unknown";
  } else { 
    return u.get().name();
  }
}

正面示例

1
2
3
4
5
public String getName(User user){
  return Optional.ofNullable(user)
                 .map(u -> u.name)
                 .orElse("Unknown");
}

总结

在写复杂逻辑时，尽量简化代码，不要让代码太代阅读起来费劲，lambda表达式并不复杂，直正复杂不好读的是正则表达式，这种习惯了之后，写起来效率高，看起来也舒服。
即使不使用lambda表达式，在写代码时也要尽量规避返回null出去。防止代码由于null引发异常。