十分钟从Java 8到Java 15

该博客将为您提供自Java 7以来增加得很棒的新功能的示例。我将展示每个Java版本的至少一项重大改进，一直到2020年秋季发布的Java 15都有。Java现在完全支持lambda，函数式编程。，通过var，具有简单构造函数的不可变集合以及多行字符串进行类型推断。此外，还有令人兴奋的新实验功能，例如数据类(记录)和密封类。最后，我将讨论Java REPL，它为快速实验提供了很高的价值。

[[384894]]

函数式编程(Java 8)

在Java 8中，功能编程和lambda被添加为语言功能。函数式编程的两个核心范例是不变的值和将函数提升为一等公民的方法。数据经过一系列修改步骤，其中每个步骤都需要一些输入并将其映射到新的输出。函数式编程可与Java中的Streams和null安全monad(可选)一起使用，如下所示…

List<String> stringList = Arrays.asList("Hello", "World", "How", "Are", "You", "Today"); 
 
//functional style 
stringList.stream() 
  .filter(s -> s.equals("Hello") || s.equals("Are")) 
  .map(s -> s + " String") 
  .forEach(System.out::println); 

流(Java 8)

对于一般的计算机程序，通常必须使用值列表，并对每个值执行给定的转换。在Java 8之前，您必须使用for循环进行此转换，但是从现在开始，您可以按以下方式使用Streams：

Stream.of("hello", "great") 
    .map(s -> s + " world") 
    .forEach(System.out::println); 
> hello world 
> great world 

map函数将一个lambda作为输入，它将应用于流中的所有元素。

流可以在列表，集合和地图上工作(通过转换)。多亏了Streams，您可以摆脱代码中几乎所有的循环!

可选项(Java 8)

Java中的另一个常见问题是空指针异常。因此，Java引入了Optional —一个monad，它包装了一个可能为null或不为null的引用。可以通过功能性方式将更新应用于此Optional：

Optional.of(new Random().nextInt(10)) 
    .filter(i -> i % 2 == 0) 
    .map(i -> "number is even: " + i) 
    .ifPresent(System.out::println); 
> number is even: 6 

在上面的代码段中，我们创建一个随机数，将其包装在Optional对象中，然后仅打印偶数。

JShell(Java 9)

最后，我们有一个Java的REPL，它的名字叫JShell!相反，您可以一次执行一个命令，然后立即看到结果。这是一个简单的示例：

$ <JDK>/bin/jshell 
jshell> System.out.println("hello world") 
hello world 

长期以来，熟悉JavaScript或Python之类的解释语言的人们都对REPL感到满意，但到目前为止，Java中缺少此功能。JShell允许定义变量，但也可以定义更复杂的实体，例如多行函数，类和执行循环。此外，JShell支持自动完成功能，如果您不知道给定Java类提供的确切方法，该功能会派上用场。

不可变集合的工厂方法(Java 9)

很长时间以来，Java中缺少对列表进行简单初始化的操作，但是现在已经过去了。以前，您必须执行以下操作：

jshell> List<Integer> list = Arrays.asList(1, 2, 3, 4) 
list ==> [1, 2, 3, 4] 

现在将其简化如下：

jshell> List<Integer> list = List.of(1, 2, 3, 4) 
b ==> [1, 2, 3, 4] 

列表，集合和映射存在这种(…)方法。它们都只用一行简单的代码就创建了一个不变的对象。

使用var进行类型推断(Java 10)

Java 10引入了新的var关键字，该关键字允许省略变量的类型。

jshell> var x = new HashSet<String>() 
x ==> [] 
 
jshell> x.add("apple") 
$1 ==> true 

在上面的代码段中，编译器可以将x的类型推断为HashSet。

此功能有助于减少样板代码并提高可读性。不过，它有一些限制：您只能在方法主体内部使用var，并且编译器会在编译时推断类型，因此所有内容仍为静态类型。

单一源文件启动(Java 11)

以前，编写一个包含一个文件的简单Java程序时，必须首先使用javac编译该文件，然后使用Java运行它。在Java 11中，您可以使用一个命令完成两个步骤。

首先，定义单个源文件Main.java：

public class Main { 
  public static void main(String[] args) { 
    System.out.println("hello world"); 
  } 
} 

现在，您可以一步编译并运行它：

$ java ./Main.java 
hello world 

对于仅由一个Java类组成的简单启动程序或实验，此用于启动单个源文件的功能将使您的生活更轻松。

Switch 表达式(Java 12)

Java 12为我们带来了Switch表达式。快速展示了该表达式与旧的switch语句有何不同。

旧的switch语句定义程序的流程：

jshell> var i = 3 
jshell> String s; 
jshell> switch(i) { 
   ...>     case 1: s = "one"; break; 
   ...>     case 2: s = "two"; break; 
   ...>     case 3: s = "three"; break; 
   ...>     default: s = "unknown number"; 
   ...> } 
jshell> s 
s ==> "three" 

相反，新的switch表达式返回一个值：

jshell> var i = 3; 
jshell> var x = switch(i) { 
   ...>     case 1 -> "one"; 
   ...>     case 2 -> "two"; 
   ...>     case 3 -> "three"; 
   ...>     default -> "unknown number"; 
   ...> }; 
x ==> "three" 

总而言之，旧的switch语句用于程序流，新的switch表达式解析为一个值。

请注意，这个新的switch语句是一种映射功能：只有一个输入(在上述情况下为i)，而只有一个输出(此处为x)。实际上，这是一种模式匹配功能，有助于使Java与函数编程原理更加兼容。类似的switch语句在Scala中已有一段时间了。

需要注意的几件事：

• 代替双点，我们使用箭头->
• 无需Break
• 当考虑所有可能的情况时，可以省略默认情况
• 要在Java 12中启用此功能，请使用–enable-preview –source 12

多行字符串(Java 13)

您是否曾经定义过长的多行字符串，例如JSON或XML?到目前为止，您可能已经将所有内容都压缩了一行并使用换行符 n，但这使String更加难以阅读。Java 13带有多行字符串!

样例：

public class Main {  
  public static void main(String [] args) { 
    var s = """ 
        { 
            "recipe": "watermelon smoothie", 
            "duration": "10 mins", 
            "items": ["watermelon", "lemon", "parsley"] 
        }"""; 
    System.out.println(s); 
  } 
} 

现在，我们通过单文件启动运行main方法：

java --enable-preview --source 13 Main.java 
 
{ 
    "recipe": "watermelon smoothie", 
    "duration": "10 mins", 
    "items": ["watermelon", "lemon", "parsley"] 
} 

结果字符串跨越多行，引号“”保留完整，甚至制表符 t也被保留!

数据类：Record 记录(Java 14)

在本文的所有新功能中，这可能是我最兴奋的功能：最后，Java中有数据类!这些类使用record关键字声明，并具有自动Getter，构造函数和equals()方法等。总之，您可以摆脱大量的样板代码!

jshell> record Employee (String name, int age, String department) {} 
|  created record Employee 
 
jshell> var x = new Employee("Anne", 25, "Legal"); 
x ==> Employee[name=Anne, age=25, department=Legal] 
 
jshell> x.name() 
$2 ==> "Anne" 

Scala对于案例类具有类似的功能，对于Kotlin具有数据类具有类似的功能。到目前为止，在Java中，许多开发人员都使用Lombok，它提供了许多功能，这些功能现在启发了Java 14的记录。有关详细信息，请参见Baeldung这篇文章。

不带Cast的instanceof(Java 14)

Java的早期版本已经包含instanceof关键字：

Object obj = new String("hello"); 
if (obj instanceof String) { 
  System.out.println("String length: " + ((String)obj).length()); 
} 
view raw 

不幸的是：首先，我们检查s是否为String类型，然后再次对其进行强制转换以获取其长度。

现在使用Java 14，编译器足够聪明，可以在instanceof检查之后自动推断类型：

Object obj = new String("hello"); 
if (obj instanceof String mystr) { 
  System.out.println("String length: " + mystr.length()); 
} 

密封的类(Java 15)

使用sealed关键字，您可以限制哪些类可以扩展给定的类或接口。这是一个例子：

public sealed interface Fruit permits Apple, Pear { 
    String getName(); 
} 
 
public final class Apple implements Fruit { 
    public String getName() { return "Apple"; } 
} 
 
public final class Pear implements Fruit { 
    public String getName() { return "Pear"; } 
} 

那么这对我们有什么帮助呢?好吧，现在您知道有多少种水果了。实际上，这是朝着完全支持的模式匹配的方向迈出的重要一步，在此模式中，您可以像对待枚举一样对待类。该密封功能与前面介绍的新开关表达式很好地结合在一起。

奖励：从Java 8开始更新的许可条款

本文的最后一个主题：许可。你们大多数人都听说Oracle停止了Java 8(免费商业版)的更新。所以这是您的选择：

• 使用较新的Oracle JDK版本(每个发行版后的6个月内，Oracle提供免费的安全更新)
• 使用旧版本的JDK后果自负
• 使用旧的OpenJDK Java版本，那些版本仍会从开源社区或第三方供应商处获得安全更新。
• 向Oracle支付主要支持费用(例如Java 8：直到2030年的支持)

在下面，您可以查看每个JDK的暂定Oracle支持期限：

> Oracle support timeline per JDK

Oracle的新许可模式受新发布周期的影响：Oracle将每6个月发布一个新的Java版本。这个新的发行周期有助于Oracle更快地改进Java，通过实验性功能获得更快的反馈，并赶上Scala，Kotlin和Python等更现代的语言。

总结

在过去的6年中，Java取得了长足的发展，此后实际上已经发布了8个新的Java版本!与其他基于JVM的竞争对手(Scala和Kotlin)相比，所有这些令人敬畏的新功能有助于使Java成为竞争选择。