jdk8到jdk17新增新特性介绍_jdk 17 scriptenginemanager-优快云博客

本文链接：https://blog.youkuaiyun.com/wustrive_2008/article/details/130200063

文章详细介绍了从JDK8到JDK17的主要特性，包括Lambda表达式、接口默认方法、新的日期/时间API、NashornJavaScript引擎、模块化系统、JShell、StreamAPI改进、HTTP客户端等功能的引入和演进，以及后续版本中的Sealed类、TextBlocks、Records、GC优化等语言特性和性能提升。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

JDK 8:

Lambda表达式和函数式接口 Lambda表达式是一个匿名方法，可以用于将行为作为参数传递给方法，或者在函数式接口中直接表示行为。Lambda表达式使用箭头 -> 将参数列表分隔开来，并且主体由花括号包含。以下是一个简单的Lambda表达式示例：
```
List<String> list = Arrays.asList("Java", "Python", "C++");
Collections.sort(list, (a, b) -> a.compareTo(b));
```
接口默认方法和静态方法接口默认方法和静态方法允许在接口中提供默认实现，这使得接口更加灵活。以下是一个接口默认方法的示例：
```
interface MyInterface {
    default void printHello() {
        System.out.println("Hello");
    }
}
```
新的日期/时间API（JSR 310）新的日期/时间API提供了一组强大的、不可变的日期和时间类，以及一些操作它们的方法。以下是一个使用新日期/时间API的示例：
```
LocalDateTime now = LocalDateTime.now();
System.out.println("Current date and time: " + now);
```

Nashorn JavaScript引擎 Nashorn JavaScript引擎允许在Java应用程序中嵌入JavaScript代码。以下是一个使用Nashorn JavaScript引擎的示例：

ScriptEngineManager engineManager = new ScriptEngineManager();
ScriptEngine engine = engineManager.getEngineByName("nashorn");
engine.eval("print('Hello World!')");

JDK 9:

模块化系统（Project Jigsaw）模块化系统允许将Java应用程序拆分为更小、更易于维护的模块，并提供了一种新的依赖管理机制。以下是一个使用模块化系统的示例：
```
module com.example.greeting {
    exports com.example.greeting;
}
```
JShell：交互式Java REPL工具 JShell是Java的交互式REPL（Read-Evaluate-Print Loop）工具，允许在命令行中编写和执行Java代码。以下是一个使用JShell的示例：
```
jshell> int a = 10;
a ==> 10
jshell> int b = 20;
b ==> 20
jshell> a + b
$3 ==> 30
```

改进的Stream API 改进的Stream API提供了一些新的方法和操作符，使得处理数据流更加容易。以下是一个使用改进的Stream API的示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
    .filter(n -> n % 2 == 0)
    .mapToInt(Integer::intValue)
    .sum();
System.out.println("The sum of even numbers is " + sum);

HTTP/2客户端 HTTP/2客户端提供了一个简单的API，使得在Java应用程序中使用HTTP/2更容易。以下是一个使用HTTP/2客户端的示例：

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("http://example.com"))
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

JDK 10:

局部变量类型推断局部变量类型推断允许在声明变量时不指定类型，而是由编译器根据上下文进行推断。以下是一个使用局部变量类型推断的示例：
```
var list = new ArrayList<String>();
list.add("Java");
list.add("Python");
System.out.println(list);
```

线程局部握手线程局部握手允许在线程创建时和销毁时执行一些操作，这使得在多线程环境下管理资源更容易。以下是一个使用线程局部握手的示例：

static ThreadLocal<Integer> counter = ThreadLocal.withInitial(() -> 0);

public static void main(String[] args) {
    IntStream.range(0, 5)
             .parallel()
             .forEach(i -> {
                 counter.set(counter.get() + 1);
                 System.out.println("Thread " + i + ": " + counter.get());
             });
}

应用类数据共享应用类数据共享（Application Class Data Sharing，ACDS）允许将Java应用程序的类元数据保存在共享归档中以提高启动时间和内存占用。以下是一个使用ACDS的示例：
```
java -XX:+UseAppCDS -XX:DumpLoadedClassList=classes.lst -XX:SharedClassListFile=classes.lst -XX:SharedArchiveFile=app-cds.jsa -cp myapp.jar com.example.MyApp
```

JDK 11:

HTTP客户端标准化 HTTP客户端标准化提供了一组标准的API，使得在Java应用程序中使用HTTP客户端更加方便。以下是一个使用HTTP客户端标准化的示例：

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://www.example.com"))
        .build();

HttpResponse<String> response =
        client.send(request, HttpResponse.BodyHandlers.ofString());

System.out.println(response.body());

Unicode 10 Unicode 10添加了超过8000个新字符，包括emoji和其他符号。以下是一个使用Unicode 10的示例：
```
System.out.println("\u1F92C"); // 输出 🤬 emoji
```
ZGC：低停顿垃圾收集器 ZGC是一种低停顿垃圾收集器，可以在几毫秒内处理数百兆甚至数千兆的堆大小。以下是一个启用ZGC的示例：
```
java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC -jar myapp.jar
```

飞行记录器飞行记录器（Flight Recorder）是一种事件分析工具，可用于监视Java应用程序的性能和行为。以下是一个使用飞行记录器的示例：

public class MyClass {
    public static void main(String[] args) throws InterruptedException {
        FlightRecorderMXBean flightRecorder = ManagementFactory.getPlatformMXBean(FlightRecorderMXBean.class);

        flightRecorder.startRecording();
        // some code to monitor
        Thread.sleep(1000);
        flightRecorder.stopRecording();

        Path path = Paths.get("recording.jfr");
        Files.write(path, flightRecorder.getRecordingData());
    }
}

JDK 12:

Switch表达式 Switch表达式是一种新的语法，使得在switch语句中使用更加灵活的表达式。以下是一个使用Switch表达式的示例：

int day = 3;
String dayName = switch (day) {
    case 1 -> "Monday";
    case 2 -> "Tuesday";
    case 3 -> "Wednesday";
    case 4 -> "Thursday";
    case 5 -> "Friday";
    default -> "Unknown";
};
System.out.println(dayName);

废弃Nashorn JavaScript引擎 Nashorn JavaScript引擎已被废弃，并将在未来的JDK版本中删除。以下是一个使用Nashorn JavaScript引擎的示例：建议改为使用其他JavaScript引擎，例如GraalVM。
```
ScriptEngineManager engineManager = new ScriptEngineManager();
ScriptEngine engine = engineManager.getEngineByName("nashorn");
engine.eval("print('Hello World!')");
```
新的字符串API 新的字符串API提供了一些方便的方法，使得在处理字符串时更加容易。以下是一个使用新的字符串API的示例：
```
String str1 = "  hello  ";
String str2 = str1.strip(); // 去除开头和结尾的空格
System.out.println(str2);
```

JDK 13:

动态CDS归档动态CDS归档允许在运行时创建和更新共享归档文件，以提高Java应用程序的启动时间和内存占用。以下是一个使用动态CDS归档的示例：

生成共享归档文件

java -XX:DumpLoadedClassList=classes.lst -XX:SharedClassListFile=classes.lst -XX:SharedArchiveFile=app-cds.jsa -cp myapp.jar com.example.MyApp

更新共享归档文件

java -Xshare:dump -XX:SharedArchiveFile=app-cds.jsa -cp myapp.jar com.example.MyApp

使用共享归档文件

java -Xshare:on -XX:SharedArchiveFile=app-cds.jsa -cp myapp.jar com.example.MyApp

ZGC：可伸缩性改进 ZGC的可伸缩性得到了改进，使得在大型系统上使用更加容易。以下是一个启用ZGC的示例：
```
java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC -jar myapp.jar
```
文本块文本块允许在Java源代码中包含多行字符串，使得处理长字符串更加容易。以下是一个使用文本块的示例：
```
String str = """
             This is a
             multi-line
             string
             """;
System.out.println(str);
```

JDK 14:

Switch表达式增强 Switch表达式增强允许在switch语句中使用更加灵活的表达式，并支持返回值。以下是一个使用Switch表达式增强的示例：

int day = 3;
String dayName = switch (day) {
    case 1 -> "Monday";
    case 2 -> "Tuesday";
    case 3, 4, 5 -> {
        String s = "Wednesday or Thursday or Friday";
        yield s;
    }
    default -> "Unknown";
};
System.out.println(dayName);

instanceof模式匹配 instanceof模式匹配允许在判断对象类型时使用更加简洁的语法。以下是一个使用instanceof模式匹配的示例：
```
Object obj = "Hello";
if (obj instanceof String str) {
    System.out.println(str.length());
}
```
Records：简化的Java类 Records是一种新的语法，用于声明一组不可变的数据，可以自动生成构造函数、getter方法和equals/hashCode方法。以下是一个使用Records的示例：
```
record Person(String name, int age) {}
Person person = new Person("Alice", 30);
System.out.println(person.name());
```

JDK 15:

Sealed类和接口 Sealed类和接口允许限制哪些类可以扩展或实现它们，从而提高代码的安全性和可读性。以下是一个使用Sealed类和接口的示例：
```
sealed interface Vehicle permits Car, Bike {}

final class Car implements Vehicle {}
final class Bike implements Vehicle {}
```

Text Blocks增强 Text Blocks增强允许在文本块中使用反斜杠和引号，从而使得处理长字符串更加方便。以下是一个使用Text Blocks增强的示例：

String jsonString = """
                    {
                        "name": "Alice",
                        "age": 30,
                        "address": {
                            "city": "New York",
                            "state": "NY"
                        }
                    }
                    """;
System.out.println(jsonString);

ZGC：并发垃圾收集 ZGC增加了并发垃圾收集的支持，使得在多核系统上使用更加高效。以下是一个启用ZGC的示例：
```
java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC -jar myapp.jar
```

JDK 16:

Records增强 Records增强允许为Record类自定义构造函数，并且支持私有字段、静态字段和方法。以下是一个使用Records增强的示例：

record Person(String name, int age) {
    private static final String DEFAULT_NAME = "Unknown";
    private String address;
    
    public Person(String name, int age, String address) {
        this(name, age);
        this.address = address;
    }
    
    public static String getDefaultName() {
        return DEFAULT_NAME;
    }
}
Person person = new Person("Alice", 30, "New York");
System.out.println(person.name());

Pattern匹配实例of Pattern匹配实例of允许对对象进行模式匹配，并且支持返回值。以下是一个使用Pattern匹配实例of的示例：
```
Object obj = "Hello";
if (obj instanceof String s && s.length() > 0) {
    System.out.println(s.toUpperCase());
}
```

Vector API Vector API提供了一组矢量化操作，可以更加高效地处理向量数据。以下是一个使用Vector API的示例：

import jdk.incubator.vector.*;

public class VectorDemo {
    public static void main(String[] args) {
        float[] a = {1, 2, 3, 4};
        float[] b = {5, 6, 7, 8};

        FloatVector va = FloatVector.fromArray(VectorSpecies_256.FLOAT, a, 0);
        FloatVector vb = FloatVector.fromArray(VectorSpecies_256.FLOAT, b, 0);

        FloatVector vc = va.add(vb);
        float[] c = new float[4];
        vc.intoArray(c, 0);

        System.out.println(Arrays.toString(c));
    }
}

JDK 17:

Sealed类和接口增强 Sealed类和接口增强允许在类型层次结构中定义Permitted Subclasses，并且支持sealed接口。以下是一个使用Sealed类和接口增强的示例：

public abstract sealed class Shape permits Circle, Rectangle {}

final class Circle extends Shape {}
final class Rectangle extends Shape {}

public sealed interface Vehicle permits Car, Bike {}
public final class Car implements Vehicle {}
public final class Bike implements Vehicle {}

public sealed interface Drawable permits Circle, Rectangle, Car {}

switch表达式增强 switch表达式增强允许在switch语句中使用多个逗号分隔的标签和嵌套case标签，从而使得处理复杂的条件更加容易。以下是一个使用switch表达式增强的示例：

int day = 3;
String dayName = switch (day) {
    case 1, 2 -> "Weekday";
    case 3, 4, 5 -> {
        String s = "Midweek";
        yield s;
    }
    case 6, 7 -> "Weekend";
    default -> throw new IllegalStateException("Unexpected value: " + day);
};
System.out.println(dayName);

GC改进 GC改进包括G1的垃圾收集器的并发线程数增加、ZGC的堆大小增加、Epsilon垃圾收集器的删除、Shenandoah垃圾收集器的低停顿时间等。以下是一个启用GC改进的示例：

java -XX:+UseG1GC -XX:ConcGCThreads=4 -Xmx2g -jar myapp.jar
java -XX:+UseZGC -XX:HeapSize=16g -jar myapp.jar
java -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC -jar myapp.jar
java -XX:+UseZGC -XX:HeapSize=16g -jar myapp.jar