Java 17 VS Java 8: 新旧对决，这些Java 17新特性你不容错过

╰半橙微兮° 2024-04-21 19:06 48阅读 0赞

Java是一门非常流行的编程语言，由于其跨平台性、可移植性以及强大的面向对象特性而备受青睐。Java最初由Sun Microsystems公司于1995年推出，随着时间的推移，Java发展迅速，版本不断更新。本篇博客将重点介绍Java 17与Java 8的对比，以及Java 17的新特性。

<table> 
 <thead> 
  <tr> 
   <th>特征</th> 
   <th>Java 17</th> 
   <th>Java 8</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>引入</td> 
   <td>2021年9月14日</td> 
   <td>2014年3月</td> 
  </tr> 
  <tr> 
   <td>垃圾收集器</td> 
   <td>ZGC（新型垃圾收集器）</td> 
   <td>G1收集器</td> 
  </tr> 
  <tr> 
   <td>其他垃圾收集器</td> 
   <td>Shenandoah GC，G1 GC，Parallel GC，Serial GC</td> 
   <td>Parallel GC，Serial GC</td> 
  </tr> 
  <tr> 
   <td>垃圾回收策略</td> 
   <td>全堆回收和增量模式</td> 
   <td>复制模式</td> 
  </tr> 
  <tr> 
   <td>应用程序类数据共享（AppCDS）</td> 
   <td>支持</td> 
   <td>不支持</td> 
  </tr> 
  <tr> 
   <td>JFR事件流</td> 
   <td>使用异步处理提高性能</td> 
   <td>未支持</td> 
  </tr> 
  <tr> 
   <td>条件性实例化卡片</td> 
   <td>支持</td> 
   <td>支持</td> 
  </tr> 
  <tr> 
   <td>嵌入式C / C ++库</td> 
   <td>JDK不包括C / C ++编译器</td> 
   <td>JDK不包括C / C ++编译器</td> 
  </tr> 
  <tr> 
   <td>算法升级</td> 
   <td>SHA-3，SM3 / SM4，Ed448，RSASSA-PSS，X25519 / X448</td> 
   <td>SHA-1，RC4，DES，MD5，DSA，DH</td> 
  </tr> 
 </tbody> 
</table>

Java 17 和 Java 8 的区别

#### 一、Java 17与Java 8的对比 ####

Java 17与Java 8是Java版本中的两个重要里程碑。Java 8是Java版本中的一次重大更新，于2014年发布，引入了很多新的特性和功能，包括Lambda表达式、Stream API、函数式接口等。Java 17是Java SE 17版本，于2021年9月发布，是Java SE 16的长期支持（LTS）版本。Java 17中也有一些新的特性和改进，我们将在后文中详细讨论。

#### 二、性能比较 ####

Java 17与Java 8在性能方面的比较非常重要。Java 8引入了一些性能改进，例如优化了字符串连接和数组排序等操作。Java 17在性能方面也有一些新的改进，例如：

*  改进了JIT编译器，提高了应用程序的性能。
 *  改进了垃圾回收器，提高了垃圾回收的效率和吞吐量。
 *  引入了C++风格的内存管理，包括对堆内存分配的优化和对垃圾回收的改进。  
    这些改进都可以提高Java应用程序的性能和响应速度。

#### 三、语言特性比较 ####

Java 8引入了一些新的语言特性，例如Lambda表达式和函数式接口。这些特性让Java程序员能够使用函数式编程的方式编写代码，从而使得代码更加简洁、易读、易维护。Java 17在语言特性方面也有一些新的改进，例如：

*  引入了Sealed类，这是一种新的类修饰符，用于限制类的继承。这样可以使得代码更加安全、可维护。
 *  引入了Pattern Matching for Switch语法，这是一种新的switch语法，可以用于模式匹配。这样可以使得代码更加简洁、易读、易维护。
 *  引入了Record类，这是一种新的数据类，可以用于定义只有属性和访问器的简单数据对象。这样可以使得代码更加简洁、易读、易维护。
 *  这些改进都可以使得Java程序员能够使用更加先进、更加高效的语言特性编写代码。

#### 四、应用场景比较 ####

Java 8和Java 17都可以用于不同的应用场景，但是它们在一些方面有所不同。Java 8适用于开发中小型应用程序和Web应用程序，例如Web服务、企业级应用程序和桌面应用程序等。Java 8也可以用于开发大型应用程序，但是在大型应用程序中可能会出现一些性能问题。Java 17则更适合用于开发大型应用程序和高性能应用程序，例如高性能计算、云计算、大数据处理等。

#### 五、Java 17的新特性 ####

Java 17是Java SE 17版本，于2021年9月发布，是Java SE 16的长期支持（LTS）版本。Java 17中有许多新的特性和改进，以下是一些主要特性：

##### 5.1 Sealed类 #####

Sealed类是一种新的类修饰符，用于限制类的继承。Sealed类可以控制哪些类可以继承自它，这样可以使得代码更加安全、可维护。Sealed类的使用可以在编译时强制执行一些规则，从而避免运行时错误。

###### 5.1.1 代码示例 ######

public sealed abstract class Shape permits Circle, Rectangle {
        
        public abstract double calculateArea();
    }
    
    public final class Circle extends Shape {
        
        private double radius;
    
        public Circle(double radius) {
        
            this.radius = radius;
        }
    
        public double getRadius() {
        
            return radius;
        }
    
        public double calculateArea() {
        
            return Math.PI * radius * radius;
        }
    }
    
    public final class Rectangle extends Shape {
        
        private double length;
        private double width;
    
        public Rectangle(double length, double width) {
        
            this.length = length;
            this.width = width;
        }
    
        public double getLength() {
        
            return length;
        }
    
        public double getWidth() {
        
            return width;
        }
    
        public double calculateArea() {
        
            return length * width;
        }
    }

**代码说明：**  
在这个示例中，Shape 是一个抽象类，并且使用 permits 关键字，明确允许哪些类继承该类。Circle 和 Rectangle 是 Shape 的子类，并使用 final 关键字来表示它们是封闭类，不允许有其他子类继承它们。这种方式可以在编译时校验代码，并防止意外创建不受预期的子类。

##### 5.2 Pattern Matching for Switch语法 #####

Pattern Matching for Switch语法是一种新的switch语法，可以用于模式匹配。Pattern Matching for Switch语法可以根据不同的模式执行不同的操作，从而使得代码更加简洁、易读、易维护。Pattern Matching for Switch语法可以减少代码量，避免出现大量的if-else语句。

###### 5.2.1 代码示例 ######

public static void main(String[] args) {
        
        Object obj = "hello";
    
        switch (obj) {
        
            case String s && s.length() > 5 -> System.out.println("长字符串");
            case String s -> System.out.println("短字符串");
            case Integer i -> System.out.println("整型数");
            default -> System.out.println("不支持的类型");
        }
    }

**代码说明：**  
在这个示例中，我们首先定义了一个 Object 类型的变量 obj，它可能是一个字符串、整型数或其他类型的对象。

接下来，我们使用了 switch 语句，并对 obj 进行了几个模式匹配：

*  如果 obj 是一个长度大于 5 的字符串，表达式 case String s && s.length() > 5 就会被匹配并执行相应的代码块。
 *  如果 obj 是一个短字符串，表达式 case String s 会匹配并执行相应代码块。
 *  如果 obj 是一个整型数，表达式 case Integer i 就会执行相应代码块。
 *  如果 obj 不属于以上任何一种类型，就会执行默认代码块。

##### 5.3 Record类 #####

Record类是一种新的数据类，可以用于定义只有属性和访问器的简单数据对象。Record类可以简化代码，使得代码更加易读、易维护。Record类的使用可以减少代码量，避免出现大量的getter和setter方法。

###### 5.3.1 代码示例 ######

public record Person(String name, int age) {
        }
    
    public class RecordExample {
        
        public static void main(String[] args) {
        
            Person person = new Person("John", 30);
    
            System.out.println("Name: " + person.name());
            System.out.println("Age: " + person.age());
        }
    }

**代码说明：**  
在这个示例中，我们定义了一个名为 Person 的 Record 类，它有两个字段：name 和 age。Record 类会自动生成一个带有这些字段的构造函数、getter 方法和 equals、hashCode 和 toString 方法。

*  我们在 main 方法中创建了一个 Person 对象，并使用 name() 和 age() 方法获取其名称和年龄信息，然后将其打印出来。
 *  使用 Record 类，我们可以更轻松地定义简单的数据类，而不需要手动编写大量的构造函数和 getter 方法。这可以使我们的代码更加简洁、清晰，并且更易于阅读和维护。

##### 5.4 改进的垃圾回收器 #####

Java 17中改进了垃圾回收器，提高了垃圾回收的效率和吞吐量。改进的垃圾回收器可以更加高效地回收内存，从而提高应用程序的性能和响应速度。

###### 5.4.1 代码示例 ######

public class GarbageCollectorExample {
        
        public static void main(String[] args) {
        
            List<Integer> list = new ArrayList<>();
    
            for (int i = 0; i < 1000000; i++) {
        
                list.add(i);
            }
    
            System.out.println("List size: " + list.size());
    
            System.gc(); // 调用垃圾回收器
    
            System.out.println("List size after GC: " + list.size());
        }
    }

**代码说明：**  
在这个示例中，我们使用了 ZGC 垃圾回收器来回收 list 对象占用的内存。我们在代码中使用了 System.gc() 方法来手动触发垃圾回收器。注意，在实际应用中，我们通常不需要手动触发垃圾回收器，因为 JVM 会自动进行垃圾回收操作。

ZGC 垃圾回收器具有可伸缩性和低延迟的特点，可以在处理大型、高并发应用程序时提供更好的性能和吞吐量。除了 ZGC，Java 17 中还引入了 Shenandoah 垃圾回收器，它也具有类似的高性能和低延迟的特点。

##### 5.5 改进的JIT编译器 #####

Java 17中改进了JIT编译器，提高了应用程序的性能。改进的JIT编译器可以更加高效地编译代码，从而提高应用程序的性能和响应速度。

###### 5.5.1 代码示例 ######

public class JITCompilerExample {
        
        public static void main(String[] args) {
        
            int sum = 0;
            for (int i = 0; i < 1000000; i++) {
        
                sum += i;
            }
            System.out.println("Sum is: " + sum);
        }
    }

在Java 17中，可以通过添加以下命令行参数来启用Graal编译器：

-XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI -XX:+UseJVMCICompiler

**代码说明：**  
当运行上述示例代码时，Graal编译器会自动将循环优化为一个简单的算术公式，从而大大提高了性能。

##### 5.6 C++风格的内存管理 #####

Java 17中引入了C++风格的内存管理，包括对堆内存分配的优化和对垃圾回收的改进。C++风格的内存管理可以使得Java应用程序更加高效，从而提高应用程序的性能和响应速度。

###### 5.6.1 代码示例 ######

import java.lang.management.MemoryPoolMXBean;
    import java.lang.management.ManagementFactory;
    
    public class MemoryManagementExample {
        
    
        public static void main(String[] args) throws InterruptedException {
        
            MemoryPoolMXBean heap = ManagementFactory.getMemoryPoolMXBeans().stream()
                    .filter(p -> p.getName().equals("Java heap")).findFirst().orElseThrow();
    
                System.out.println("Heap memory utilization statistics:\n");
    
                try (var scope = heap.reserveMemory(1024 * 1024)) {
        
                    long usedMemory = heap.getUsage().getUsed();
                    long commitedMemory = heap.getUsage().getCommitted();
    
                    System.out.printf("Before allocation: used=%d, committed=%d%n", usedMemory, commitedMemory);
    
                    byte[] array = new byte[1024 * 1024];
    
                    usedMemory = heap.getUsage().getUsed();
                    int capacity = scope.getBytesReserved();
    
                    System.out.printf("After allocation: used=%d, committed=%d, capacity=%d%n", usedMemory, commitedMemory,
                            capacity);
                }
    
                long usedMemory = heap.getUsage().getUsed();
                long commitedMemory = heap.getUsage().getCommitted();
    
                System.out.printf("After scope: used=%d, committed=%d%n", usedMemory, commitedMemory);
        }
    
    }

**代码说明：**

*  定义了一个名为 MemoryManagementExample 的类，然后获取 Java heap 内存池，并在 try-with-resources 语句中创建了一个名为 scope 的资源。
 *  然后，我们打印了内存使用率统计信息，并在 scope 内部分配了一个 1MB 的字节数组。我们使用 getBytesReserved() 方法获取作用域中已保留的字节数，并打印了内存使用情况和容量等信息。
 *  最后，我们打印了作用域结束后内存的使用情况。

##### 5.7 增强的Java集合库 #####

Java 17中增强了Java集合库，包括新增了一些集合类型和对现有集合类型的改进。增强的Java集合库可以提高开发人员的开发效率和代码质量，从而减少出现错误的可能性。同时，增强的Java集合库也可以提高应用程序的性能和响应速度，使得Java应用程序更加高效。

###### 5.7.1 代码示例 ######

1.  of() 方法：创建一个不可变的集合

List<String> list = List.of("apple", "banana", "orange");
    Set<Integer> set = Set.of(1, 2, 3, 4);
    Map<String, Integer> map = Map.of("apple", 1, "banana", 2, "orange", 3);

1.  forEach() 方法：遍历集合

List<String> list = List.of("apple", "banana", "orange");
    list.forEach(name -> System.out.println(name));
    Set<Integer> set = Set.of(1, 2, 3, 4);
    set.forEach(number -> System.out.println(number));

1.  Collectors类：提供了一系列的归约操作

List<String> list = List.of("apple", "banana", "orange");
    String joinedString = list.stream().collect(Collectors.joining("-", "[", "]"));
    System.out.println(joinedString);
    
    Map<String, Integer> map = Map.of("apple", 1, "banana", 2, "orange", 3);
    Map<Integer, String> reversedMap = map.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
    System.out.println(reversedMap);

1.  takeWhile() 方法和 dropWhile() 方法：根据条件截取集合

List<Integer> list = List.of(1, 2, 3, 4, 5, 6, 7);
    List<Integer> takenList = list.stream().takeWhile(number -> number < 5).collect(Collectors.toList());
    System.out.println(takenList);
    
    List<Integer> dropedList = list.stream().dropWhile(number -> number < 5).collect(Collectors.toList());
    System.out.println(dropedList);

1.  toArray(IntFunction<T\[\]>) 方法：返回集合中的所有元素到一个新数组中

List<String> list = List.of("apple", "banana", "orange");
    String[] array = list.toArray(String[]::new);
    System.out.println(Arrays.toString(array));