从Java 8 到 Java 14，几个令人印象深刻的新特性

1.Lambda 表达式

Lambda表达式时Java 8中的一个新特性，它允许许把函数作为一个方法的参数（函数作为参数传递进方法中）。

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

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

Lambda 表达式的简单例子:

// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

Lambda表达式的一个简单用例：

//定义接口
interface MathOperation {
      int operation(int a, int b);
   }
    
   interface GreetingService {
      void sayMessage(String message);
   }

public class Java8Tester {
    
   private int operate(int a, int b, MathOperation mathOperation){
      return mathOperation.operation(a, b);
   }
   
   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");
   }
}

输出结果：

$ javac Java8Tester.java
$ java Java8Tester
10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2
Hello Runoob
Hello Google

使用 Lambda 表达式需要注意以下两点：

• Lambda 表达式主要用来定义接口中逻辑较为简单的方法，最后作为参数传入方法中。
• Lambda 表达式免去了使用匿名方法的麻烦，但同时也会带来调试困难，新人理解成本高等缺点。

2.Stream API

在Java 8之前，集合和数组的处理并不是很便捷，但Stream API的出现可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。

简单例子：

//filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤掉空字符串：
List<String> strings = Arrays.asList("Ben", "", "Ryan", "D", "ben");
strings.stream().filter(string -> !string.isEmpty()).forEach(System.out::println);
//Ben, , Ryan, D, ben

//map 方法用于映射每个元素到对应的结果，以下代码片段使用 map 输出了元素对应的平方数：
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
numbers.stream().map( i -> i*i).forEach(System.out::println);
//9,4,4,9,49,9,25

//limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素。以下代码片段使用 limit 方法保理4个元素：
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
numbers.stream().limit(4).forEach(System.out::println);
//3,2,2,3

//sorted 方法用于对流进行排序。以下代码片段使用 sorted 方法进行排序：
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
numbers.stream().sorted().forEach(System.out::println);
//2,2,3,3,3,5,7

//distinct主要用来去重，以下代码片段使用 distinct 对元素进行去重：
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
numbers.stream().distinct().forEach(System.out::println);
//3,2,7,5

最后可通过最终操作将处理过的流，转换成我们需要的集合类型或者计算出流中元素个数、输出流等操作。

//Stream 提供了方法 'forEach' 来迭代流中的每个数据。以下代码片段使用 forEach 输出了10个随机数：
Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

//count用来统计流中的元素个数。
List<String> strings = Arrays.asList("Hello", "HelloWorld", "Ryan");
System.out.println(strings.stream().count());
//3

//collect就是一个归约操作，可以接受各种做法作为参数，将流中的元素累积成一个汇总结果：
List<String> strings = Arrays.asList("Ben", "BenChuang", "ben","Ben666", "Hello", "HelloWorld", "Ben");
strings = strings.stream().filter(string -> string.startsWith("Ben")).collect(Collectors.toList());
System.out.println(strings);
//Ben, BenChuang, Ben666, Ben

3.本地变量类型推断

在Java 10之前版本中，我们想定义定义局部变量时。我们需要在赋值的左侧提供显式类型，并在赋值的右边提供实现类型：

MyObject value = new MyObject();

在Java 10中，提供了本地变量类型推断的功能，可以通过var声明变量：

var value = new MyObject();

本地变量类型推断将引入“var”关键字，而不需要显式的规范变量的类型。

其实，所谓的本地变量类型推断，也是Java 10提供给开发者的语法糖。虽然我们在代码中使用var进行了定义，但是对于虚拟机来说他是不认识这个var的，在java文件编译成class文件的过程中，会进行解糖，使用变量真正的类型来替代var。

4.Switch 表达式

在JDK 12中引入了Switch表达式作为预览特性。并在Java 13中修改了这个特性，引入了yield语句，用于返回值。而在之后的Java 14中，这一功能正式作为标准功能提供出来。

在以前，我们想要在switch中返回内容，还是比较麻烦的，一般语法如下：

int i;
switch (x) {
    case "1":
        i=1;
        break;
        
    case "2":
        i=2;
        break;
        
    default:
        i = x.length();
        break;
}

在JDK13中使用以下语法：

int i = switch (x) {

    case "1" -> 1;

    case "2" -> 2;

    default -> {
        int len = args[1].length();
        yield len;
    }
};

或者

int i = switch (x) {

    case "1": yield 1;

    case "2": yield 2;

    default: {
        int len = args[1].length();
        yield len;
    }
};

在这之后，switch中就多了一个关键字用于跳出switch块了，那就是yield，他用于返回一个值。和return的区别在于：return会直接跳出当前循环或者方法，而yield只会跳出当前switch块。

总结

以上就是从Java 8 到 Java 14，几个令人印象深刻的新特性，新的这些功能，确实一定程度上使开发编码变得更加高效简化，但是也带来了对应的成本，如调试困难，新人理解成本高等缺点，虽然如此，但是我们也需要时刻保持对新特性的了解，然后根据自身开发场景的需求进行选择~