Java 8 新特性

目前自己的项目已经使用上了jdk8,但是基本上用的还是jdk8之前的语法和规范。略感惭愧。赶紧学习一下jdk8的新特性。据说有好玩好用的东西。

---

新特性

java8的新特性还算挺多，我就记录一些我自己觉得比较常用的。想要看所有的新特性，可以查看官网jdk新特性

• Lambda 表达式 − Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中。
• Optional 类 − Optional 类已经成为 Java 8 类库的一部分，用来解决空指针异常。允许我们在JVM上运行特定的javascript应用。
• 方法引用 − 方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。
• 默认方法 − 默认方法就是一个在接口里面有了一个实现的方法。
• Stream API −新添加的Stream API（java.util.stream） 把真正的函数式编程风格引入到Java中。
• Date Time API − 加强对日期与时间的处理。

Lambda 表达式

Lambda 表达式的加入，使得 Java 拥有了函数式编程的能力。在其它语言中，Lambda 表达式的类型是一个函数；但在 Java 中，Lambda 表达式被表示为对象，因此它们必须绑定到被称为功能接口的特定对象类型.

• Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。
• Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
• 使用 Lambda 表达式可以使代码变的更加简洁紧凑。

语法

lambda 表达式的语法格式如下：

(parameters) -> expression
或
(parameters) ->{ statements; }

以下是lambda表达式的重要特征:

• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
• 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
• 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

使用示例

public class Java8Tester {
   public static void main(String args[]){
      Java8Tester tester = new Java8Tester();
        
      // 类型声明
      MathOperation addition = (int a, int b) -> a + b;
        
      // 不用类型声明
      MathOperation subtraction = (a, b) -> a - b;
        
      // 大括号中的返回语句
      MathOperation multiplication = (int a, int b) -> { return a * b; };
        
      // 没有大括号及返回语句
      MathOperation division = (int a, int b) -> a / b;
        
      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
      System.out.println("10 / 5 = " + tester.operate(10, 5, division));
        
      // 不用括号
      GreetingService greetService1 = message ->
      System.out.println("Hello " + message);
        
      // 用括号
      GreetingService greetService2 = (message) ->
      System.out.println("Hello " + message);
        
      greetService1.sayMessage("Runoob");
      greetService2.sayMessage("Google");
   }
    
   interface MathOperation {
      int operation(int a, int b);
   }
    
   interface GreetingService {
      void sayMessage(String message);
   }
    
   private int operate(int a, int b, MathOperation mathOperation){
      return mathOperation.operation(a, b);
   }
}

Optional 类

个人觉得这个类还是非常方便的。可以少写很多判断，用一行代码可以写出优雅的代码。

类方法

序号  方法 & 描述
1   static <T> Optional<T> empty()
    返回空的 Optional 实例。
2   boolean equals(Object obj)
    判断其他对象是否等于 Optional。
3   Optional<T> filter(Predicate<? super <T> predicate)
    如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。
4   <U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper)
    如果值存在，返回基于Optional包含的映射方法的值，否则返回一个空的Optional
5   T get()
    如果在这个Optional中包含这个值，返回值，否则抛出异常：NoSuchElementException
6   int hashCode()
    返回存在值的哈希码，如果值不存在 返回 0。
7   void ifPresent(Consumer<? super T> consumer)
    如果值存在则使用该值调用 consumer , 否则不做任何事情。
8   boolean isPresent()
    如果值存在则方法会返回true，否则返回 false。
9   <U>Optional<U> map(Function<? super T,? extends U> mapper)
    如果存在该值，提供的映射方法，如果返回非null，返回一个Optional描述结果。
10  static <T> Optional<T> of(T value)
    返回一个指定非null值的Optional。
11  static <T> Optional<T> ofNullable(T value)
    如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional。
12  T orElse(T other)
    如果存在该值，返回值， 否则返回 other。
13  T orElseGet(Supplier<? extends T> other)
    如果存在该值，返回值， 否则触发 other，并返回 other 调用的结果。
14  <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)
    如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常
15  String toString()
    返回一个Optional的非空字符串，用来调试

示例

    public static void main(String args[]){
   
      Java8Tester java8Tester = new Java8Tester();
      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);
      System.out.println(java8Tester.sum(a,b));
   }
    
   public Integer sum(Optional<Integer> a, Optional<Integer> b){
    
      // Optional.isPresent - 判断值是否存在
        
      System.out.println("第一个参数值存在: " + a.isPresent());
      System.out.println("第二个参数值存在: " + b.isPresent());
        
      // Optional.orElse - 如果值存在，返回它，否则返回默认值
      Integer value1 = a.orElse(new Integer(0));
        
      //Optional.get - 获取值，值需要存在
      Integer value2 = b.get();
      return value1 + value2;
   }
   
   //执行结果
   /*
    第一个参数值存在: false
    第二个参数值存在: true
    10
    */