jdk8到jdk17新增新特性介绍

JDK 8:

1. Lambda表达式和函数式接口 Lambda表达式是一个匿名方法，可以用于将行为作为参数传递给方法，或者在函数式接口中直接表示行为。Lambda表达式使用箭头 -> 将参数列表分隔开来，并且主体由花括号包含。以下是一个简单的Lambda表达式示例：

   List list = Arrays.asList("Java", "Python", "C++");
   Collections.sort(list, (a, b) -> a.compareTo(b));
   

2. 接口默认方法和静态方法 接口默认方法和静态方法允许在接口中提供默认实现，这使得接口更加灵活。以下是一个接口默认方法的示例：

   interface MyInterface {
       default void printHello() {
           System.out.println("Hello");
       }
   }
   

3. 新的日期/时间API（JSR 310） 新的日期/时间API提供了一组强大的、不可变的日期和时间类，以及一些操作它们的方法。以下是一个使用新日期/时间API的示例：

   LocalDateTime now = LocalDateTime.now();
   System.out.println("Current date and time: " + now);
   

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

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

 JDK 9:

        

1. 模块化系统（Project Jigsaw） 模块化系统允许将Java应用程序拆分为更小、更易于维护的模块，并提供了一种新的依赖管理机制。以下是一个使用模块化系统的示例：

   module com.example.greeting {
       exports com.example.greeting;
   }
   

2. 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
   

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

   List 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);
   

4. 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 response = client.send(request, HttpResponse.BodyHandlers.ofString());
   System.out.println(response.body());
   

JDK 10:

1. 局部变量类型推断 局部变量类型推断允许在声明变量时不指定类型，而是由编译器根据上下文进行推断。以下是一个使用局部变量类型推断的示例：

   var list = new ArrayList();
   list.add("Java");
   list.add("Python");
   System.out.println(list);
   

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

   static ThreadLocal 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());
                });
   }
   

3. 应用类数据共享 应用类数据共享（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:

        

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

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

2. Unicode 10 Unicode 10添加了超过8000个新字符，包括emoji和其他符号。以下是一个使用Unicode 10的示例：

   System.out.println("\u1F92C"); // 输出  emoji
   

3. ZGC：低停顿垃圾收集器 ZGC是一种低停顿垃圾收集器，可以在几毫秒内处理数百兆甚至数千兆的堆大小。以下是一个启用ZGC的示例：

   java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC -jar myapp.jar
   

4. 飞行记录器 飞行记录器（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: 

1. 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);
   

2. 废弃Nashorn JavaScript引擎 Nashorn JavaScript引擎已被废弃，并将在未来的JDK版本中删除。以下是一个使用Nashorn JavaScript引擎的示例：建议改为使用其他JavaScript引擎，例如GraalVM。

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

3. 新的字符串API 新的字符串API提供了一些方便的方法，使得在处理字符串时更加容易。以下是一个使用新的字符串API的示例：

   String str1 = "  hello  ";
   String str2 = str1.strip(); // 去除开头和结尾的空格
   System.out.println(str2);
   

JDK 13:

        

1. 动态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
   

2. ZGC：可伸缩性改进 ZGC的可伸缩性得到了改进，使得在大型系统上使用更加容易。以下是一个启用ZGC的示例：

   java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC -jar myapp.jar
   

3. 文本块 文本块允许在Java源代码中包含多行字符串，使得处理长字符串更加容易。以下是一个使用文本块的示例：

   String str = """
                This is a
                multi-line
                string
                """;
   System.out.println(str);
   

JDK 14: 

        

1. 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);
   

2. instanceof模式匹配 instanceof模式匹配允许在判断对象类型时使用更加简洁的语法。以下是一个使用instanceof模式匹配的示例：

   Object obj = "Hello";
   if (obj instanceof String str) {
       System.out.println(str.length());
   }
   

3. 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: 

        

1. Sealed类和接口 Sealed类和接口允许限制哪些类可以扩展或实现它们，从而提高代码的安全性和可读性。以下是一个使用Sealed类和接口的示例：

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

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

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

3. ZGC：并发垃圾收集 ZGC增加了并发垃圾收集的支持，使得在多核系统上使用更加高效。以下是一个启用ZGC的示例：

   java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC -jar myapp.jar
   

JDK 16:

        

1. 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());
   

2. Pattern匹配实例of Pattern匹配实例of允许对对象进行模式匹配，并且支持返回值。以下是一个使用Pattern匹配实例of的示例：

   Object obj = "Hello";
   if (obj instanceof String s && s.length() > 0) {
       System.out.println(s.toUpperCase());
   }
   

3. 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: 

        

1. 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 {}
   

2. 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);
   

3. 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