函数式编程（Java 8）

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

流（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可以在Lists，Sets和Maps（通过转换）上工作。多亏了Streams，您可以摆脱代码中几乎所有的循环！

Optional（Java 8）

Java中的另一个常见问题是Null Pointer Exceptions。因此，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！简而言之，JShell允许在不编写和编译完整Java类的情况下尝试Java代码段。相反，您可以一次执行一个命令，然后立即看到结果。这是一个简单的例子：

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

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

不可变集合的工厂方法（Java 9）

ListsJava的简单初始化早已丢失，但现在已经过去了。以前，您必须执行以下操作：

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

现在将其简化如下：

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

List，Set和Mapof(...)存在这种奇特的方法。它们都只用一行简单的代码就创建了一个不变的对象。

使用var（Java 10）进行 类型推断

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

jshell> var x = new HashSet()
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语句已经在斯卡拉推出已有一段时间。

需要注意的几件事：

代替双点，我们使用箭头 ->

不需要 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，它提供了许多现在受recordsJava 14启发的功能。有关更多详细信息，请参见Baeldung文章。

instanceof 没有演员表（Java 14）

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

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

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

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

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"; }
}

那么这对我们有什么帮助呢？好吧，现在您知道有多少个了Fruits。实际上，这是朝着完全支持的模式匹配的方向迈出的重要一步，在该模式下，您可以像对待枚举一样对待类。此sealed功能与switch前面说明的新表达式很好地结合在一起。