Java 8 新特性

Question

接口的静态方法和默认方法

在 Java 8 以前，接口只能包含抽象方法，但从 Java 8 开始，可以通过 static 或 default 关键字在接口中定义含具体行为实现的方法。

使用 static 或 default 实现的接口静态方法或默认方法，都可以被实现类重写（覆盖）。

以下是 Java 8 中接口静态方法和默认方法的定义和使用示例代码：

public class LearnTest {

  interface Vehicle {

    static String producer() {
      return "BMW";
    }

    default String getOverview() {
      return "The Car made by " + producer();
    }
  }

  class VehicleImpl implements Vehicle {

  }

  public void test() {

    // 调用接口静态方法
    System.out.println(Vehicle.producer());

    // 调用接口默认方法
    Vehicle vehicle = new VehicleImpl();
    System.out.println(vehicle.getOverview());
  }

  public static void main(String[] args) {

    LearnTest test = new LearnTest();
    test.test();
  }
}

方法引用

方法引用是 Lambda 表达式的替代方案，当 Lambda 表达式仅仅是调用现有方法时，可以使用方法引用进行替代，使代码更短、更具可读性。

方法引用有四种变体：

• 静态方法引用： ContainingClass::methodName
• 实例方法引用： containingInstance::methodName
• 对象方法引用： ContainingType::methodName
• 构造方法引用： ClassName::new

Optional

在 Java 8 之前，开发人员必须仔细验证引用的值，因为有可能抛出 NullPointerException （NPE）。所有这些检查都需要相当烦人且容易出错的样板代码。

Java 8 可选 Optional<T> 类可以帮助处理有可能获得 NPE 的情况。它作为类型 T 对象的容器。如果这个值不是 null ，则它会返回这个对象的值。当这个容器中的值为 null 时，它允许执行一些预定义的操作，而不是抛出 NPE。

创建 Optional

1、通过静态方法创建 Optional 对象：

Optional<String> optional = Optional.empty();

2、返回一个包含非空值（non-null）的 Optional 对象：

String str = "value";
Optional<String> optional = Optional.of(str);

3、返回一个包含空值（null）的 Optional 对象：

Optional<String> optional = Optional.ofNullable(getString());

使用 Optional

比如，我们在获取一个 List<String> 时，当其值为 null 时，想要替换为一个空的列表对象，即 ArrayList<String> 实例对象。Java 8 以前的代码：

List<String> list = getList();
List<String> listOpt = list != null ? list : new ArrayList<>();

Java 8 开始可以用更短的代码实现相同的功能：

List<String> listOpt = getList().orElseGet(() -> new ArrayList<>());

再比如要实现以下这个功能，假设有一个 User 类型的对象，它有一个 Address 类型的字段，该字段包含 String 类型的 Street 字段。如果 street 字段存在，则返回该 street 字段的值；如果 street 字段为 null ，则需要返回默认值。

User user = getUser();
if (user != null) {
  Address address = user.getAddress();
  if (address != null) {
    String street = address.getStreet();
    if (street != null) {
      return street;
    }
  }
}
return "not specified";

这可以通过 Optional 简化代码：

Optional<User> user = Optional.ofNullable(getUser());
String result = user
  .map(User::getAddress)
  .map(Address::getStreet)
  .orElse("not specified");

如果上面的 getters 返回的是 Optional<T> ，则要使用 flatMap() 替代 map() ：

Optional<OptionalUser> optionalUser = Optional.ofNullable(getOptionalUser());
String result = optionalUser
  .flatMap(OptionalUser::getAddress)
  .flatMap(OptionalAddress::getStreet)
  .orElse("not specified");

Optional 的另一个用例是将前面所谈到的 NPE 替换为其他异常。在 Java 8 之前的代码实现为：

String value = null;
String result = "";
try {
    result = value.toUpperCase();
} catch (NullPointerException exception) {
    throw new CustomException();
}

Java 8 开始，我们的代码可以简化为：

String value = null;
Optional<String> valueOpt = Optional.ofNullable(value);
String result = valueOpt.orElseThrow(CustomException::new).toUpperCase();