2020年9月15号，Oracle正式发布了JDK15, 笔者第一时间了解了相关特性，在进行深入学习之后，值此元旦佳节前夕，特给大家献上此文。此次Java15的新特性有哪些？Java自JDK8开始，你了解了哪些特性呢？对于JDK的发布，我们应该怎么去学习？让我们一起来看看。

一、Java历史简谈

 1995 年 5 月，Sun Microsystems 公司发布了Java，一转眼，今年是Java的25岁诞辰了。这25年间，Java已经发布和预期发布的版本如下图：

可以看到，在Java8之前，Java的版本更新基本都是两年一个新版本，而在Java9之后，也就是2017年9月，Java平台的主架构师 Mark Reinhold 发出提议，要求将Java的功能更新周期从之前的每两年一个新版本缩减到每六个月一个新版本。

Java 8 与 Java 11 为目前提供支持的LTS（长期支持）版本，2021年9月，Java17将会成为最新的LTS版；Oracle 官方表示，会在 2019 年 1 月前为商业用途中的 Java 8 长期支持，而针对非商用的更新将继续提供，直至 2020 年 12 月；此外，AdoptOpenJDK 也为 Java 8 提供免费更新。针对 Java 11 的长期支持将不再由 Oracle 提供，而是改由 OpenJDK 社区的 AdoptOpenJDK 提供。

二、我们该如何学习Java新特性

在过去的这些年中，Java 在过去增强功能的推动下为用户提供了超过二十年的创新。例如：

JDK 5:enum、泛型、自动装箱与拆箱、可变参数、增强循环等
JDK 6:支持脚本语言、JDBC4.0API
JDK 7:支持try-with-resources、switch语句块增加String支持、NIO2.0包
JDK 8:lambda表达式、Stream API、新的日期时间的API、方法引用、构造器引用
JDK 9:模块化系统、jshell
JDK 10:局部变量的类型推断
JDK 11:ZGC的引入、Epsilon GC
JDK 12:switch表达式、Shenandoah GC、增强G1
JDK 13:switch表达式引入yield、文本块
JDK 14:instanceof模式识别、Records、弃用Parallel Scavenge+Serial GC组合、删除CMS GC

Java8之后的新特性，估计很多人都没怎么用过。那这些新特性有哪些可以应用的场景？Java新特性我们应该应该关注哪些点呢？笔者认为有以下三点比较重要：

角度一：语法层面
 例如lambda表达式，switch，自动装箱和拆箱、enum、接口中的静态方法、默认方法、私有方法
 
角度二：API层面
 例如Stream API、新的日期时间的API、Optional、String、集合框架
 
角度三：底层优化 
例如JVM的优化、元空间、GC、GC的组合、GC的参数、js的执行引擎、集合底层的实现

这次发布的主要功能有：

对应中文特性：(JEP：JDK Enhancement Proposals，JDK 增强建议，也就是 JDK 的特性新增和改进提案。)
 
JEP 339：EdDSA 数字签名算法
JEP 360：密封类（预览）
JEP 371：隐藏类
JEP 372：移除 Nashorn JavaScript 引擎
JEP 373：重新实现 Legacy DatagramSocket API
JEP 374：禁用偏向锁定
JEP 375：instanceof 模式匹配（第二次预览）
JEP 377：ZGC：一个可扩展的低延迟垃圾收集器
JEP 378：文本块
JEP 379：Shenandoah:低暂停时间垃圾收集器
JEP 381：移除 Solaris 和 SPARC 端口
JEP 383：外部存储器访问 API（第二次孵化版）
JEP 384：Records（第二次预览）
JEP 385：废弃 RMI 激活机制

我们可以看到，Java 15为用户提供了14项主要的增强/更改，主要是对之前版本预览特性的功能做了确定，如文本块、ZGC等，包括一个孵化器模块，三个预览功能，两个不推荐使用的功能以及两个删除功能。相对于Java14的16个新特性，包含的 JEP（Java/JDK Enhancement Proposals，JDK 增强提案）比 Java 12和 13 加起来的还要多，Java15可以说是平平无奇，让人内心毫无波澜。

从上图我们还可以看到，一些features后面带有preview字样，还有一些带有incubator字样，这些即预览和孵化器模块：

➢ “孵化器模块”：将尚未定稿的API和工具先交给开发者使用，以获得反馈，并用这些反馈进一步改进Java平台的质量。

➢ “预览特性”：是规格已经成型、实现已经确定，但还未最终定稿的功能。它们出现在Java中的目的是收集在真实世界中使用后的反馈信息，促进这些功能的最终定
稿。这些特性可能会随时改变，根据反馈结果，这些特性甚至可能会被移除，但通常所有预览特性最后都会在Java中固定下来。

下面，就让我们一起来学习一下此次Java15的超实用新特性吧！

三、Java15新特性详解

在开始使用Java15新特性之前，我们应该先安装好对应的JDK和开发工具，支持Java15的开发工具官网称有以下三款：

   ♣ JetBrains IDEA
   ♣ Apache NetBeans
   ♣ Eclipse Marketplace

笔者常用的是idea，系统是win10，运行jdk15需要idea2020.02及以上版本才能支持，下载地址如下：

JDK15下载路径：
https://www.oracle.com/java/technologies/javase-jdk15-downloads.html 
IDEA 2020.02版本下载地址：
https://www.jetbrains.com/idea/download/#section=windows

考虑到大多数人电脑中还有使用Java8的必要，以及开发过程中jdk切换的便利性，安装过程可以参考这篇文章：win10 64位系统中安装多个jdk版本的切换问题

安装完成之后，就让我们一起来看看Java15新特性的使用吧。

1、主要的6个新特性：

特性一：密封类（语法层面）

JEP 360: Sealed Classes (Preview)

通过密封的类和接口来增强 Java 编程语言，这是新的预览特性。

用于限制超类的使用，密封的类和接口限制其它可能继承或实现它们的其它类或接口。
 
这个特性的目标包括——允许类或接口的开发者来控制哪些代码负责实现，提供了比限制使用超类的访问修饰符声明方式更多选择,并通过支持对模式的详尽分析而支持模式匹配的未来发展。
 
在Java中，类层次结构通过继承实现代码的重用，父类的方法可以被许多子类继承。
但是，类层次结构的目的并不总是重用代码。有时，其目的是对域中存在的各种可能性进行建模，例如图形库支持的形状类型或金融应用程序支持的贷款类型。当以这种方式使用类层次结构时，我们可能需要限制子类集从而来简化建模。
 
具体使用：
因为我们引入了sealed class或interfaces，这些class或者interfaces只允许被指定的类或者interface进行扩展和实现。
 
使用修饰符sealed，您可以将一个类声明为密封类。密封的类使用reserved关键字permits列出可以直接扩展它的类。子类可以是最终的，非密封的或密封的。
 
示例：

package com.example.geometry;

abstract sealed class Shape permits Circle,Rectangle,Square{}
final class Circle    extends Shape {}
non-sealed class Rectangle extends Shape {}
sealed class Square extends Shape {}
final class TransparentRectangle extends Square{};

可以看到：

① 在声明为sealed的类Shape即为密封类，密封类必须有subclass，即子类;

② 密封类的子类可以为finall、non-sealed、sealed所修饰，如果子类也为sealed，则其也必须有子类。例如Shape的子类Square必须有子类TransparentRectangle；

③ permits修饰符是为了限制可以继承该类的所有子类，例如上述Shape类，就只能被Circle,Rectangle,Square所继承，而其他继承它的类，IDE就会直接报错；如果没有permits修饰符，例如Square类，就可以被任意类所继承。

特性二：instanceof 自动匹配模式（语法层面）

JEP 375：Pattern Matching for instanceof (Second Preview) 

在Java 14中作为预览语言功能引入的instanceof模式匹配，在Java 15中处于第二次预览，而没有任何更改。
 
模式匹配允许程序中的通用逻辑（主要是从对象中的条件提取组件）可以更简洁地表达。Haskell 和 C# 等语言已采用模式匹配来实现简洁和安全性。
 
例如，我们之前对比两个对象是否同一类型，一般的写法如下：

    // 新特性之前
    @Test
    public void test1() {
        Object o = new String("hello, java 15");
        o = new School();
        if (o instanceof String) {
            String str = (String) o; // 必须显式的声明强制类型转换
            System.out.println(str.contains("java"));
        } else {
            System.out.println("it is not string");
        }
    }

而有了新特性之后，我们可以这么写：

    @Test
    public void test2() {
        Object o = new String("hello, java 15");
        o = new School();
        if (o instanceof String str) { // you do not need to convert type
            System.out.println(str.contains("java"));
        } else {
            System.out.println("it is not string");
        }
    }

再比如，我们之前写equals方法，对比两个对象是否完全相同，现在可以这么写：

class School {
    private String student;
    private String teacher;

    //新特性之前
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof School)) return false;
        School school = (School) o;
        return student.equals(school.student) && teacher.equals(school.teacher);
    }
    //新特新之后
    public boolean equal(Object o) {
        if (this == o) return true;
        return o instanceof School school &&
                student.equals(school.student) &&
                teacher.equals(school.teacher);
    }
}

特性三：文本块功能（语法层面）

JEP 378：Text Blocks

Text Blocks首次是在JDK 13中以预览功能出现的，然后在JDK 14中又预览了一次，终于在JDK 15中被确定下来，可放心使用了。
 
文本块是一种多行字符串文字，它避免了大多数转义序列的需要，以一种可预测的方式自动设置字符串的格式，并在需要时使开发人员可以控制格式，简化编写 Java 程序的任务。
 
文本块建议的目标是提高 Java 程序中的字符串的可读性，这些字符串表示以非 Java 语言编写的代码。
另一个目标是支持从字符串文本迁移，规定任何新构造都可以表达与字符串文本相同的字符串集，解释相同的转义序列，并且以与字符串文本相同的方式进行操作。OpenJDK 开发人员希望添加转义序列来管理显式空白和换行控件。
 

举个栗子：

package com.shenzhi.belina.entity;

import org.junit.jupiter.api.Test;

public class TextBlocksTest {

    @Test
    public void test1() {
        String text1 = "The Sound of silence\n" +
                "Hello darkness , my old friend\n" +
                "I 've come to talk with you again\n";

        System.out.println(text1);
        System.out.println();
        //   jdk13
        String text = """
                The Sound of silence
                Hello darkness , my old friend
                I 've come to talk with you again
                """;
        System.out.println(text);
        System.out.println(text1.length());
        System.out.println(text.length());
    }

    //html
    @Test
    public void test2(){
        String html1 = "<html lang=\"en\">\n" +
                "<head>\n" +
                "    <meta charset=\"UTF-8\">\n" +
                "    <title>java14新特性</title>\n" +
                "</head>\n" +
                "<body>\n" +
                "    <p>hello,java</p>\n" +
                "</body>\n" +
                "</html>";
        //jdk13中的新特性：
        String html2 = """
                <html lang="en">
                <head>
                    <meta charset="UTF-8">
                    <title>java14新特性</title>
                </head>
                <body>
                    <p>hello,java</p>
                </body>
                </html>
                """;
        System.out.println(html1+html2);
    }

    //json
    @Test
    public void test3() {
        //jdk13之前的写法
        String myJson = "{\n" +
                "    \"name\":\"Lee Hongbin\",\n" +
                "     \"address\":\"lihongbin.io\",\n" +
                "    \"email\":\"zooadmin@126.com\"\n" +
                "}";
        StringBuilder filePath = new StringBuilder();

        //jdk13的新特性
        String myJson1 = """
                {
                    "name":"Lee Hongbin",
                     "address":"lihongbin.io",
                    "email":"zooadmin@126.com"
                }""";
        System.out.println(myJson1);
    }

    //sql
    @Test
    public void test4(){
        String sql = "SELECT id,NAME,email\n" +
                "FROM customers\n" +
                "WHERE id > 4\n" +
                "ORDER BY email DESC";
        System.out.println(sql);
        //jdk13新特性：
        String sql1 = """
                SELECT id,NAME,email
                FROM customers
                WHERE id > 4
                ORDER BY email DESC
                """;
        System.out.println();
        System.out.println(sql1);
    }
    //jdk14新特性
    @Test
    public void test5(){
        String sql1 = """
                SELECT id,NAME,email
                FROM customers
                WHERE id > 4
                ORDER BY email DESC
                """;
        System.out.println(sql1);

        // \:取消换行操作
        // \s:表示一个空格
        String sql2 = """
                SELECT id,NAME,email \
                FROM customers\s\
                WHERE id > 4 \
                ORDER BY email DESC\
                """;
        String sql3 = """
                select id,name,email \
                from customers\s\
                where id > 4\
                order by emial \s desc
                """;

        System.out.println(sql2);
        System.out.println(sql3);
        System.out.println(sql2.length());
    }
}

具体的区别，各位读者可以在运行代码后细品，不再赘述。

特性四：Records（语法层面）

JEP 384：Records Class(Second Preview)

早在2019年2月份，Java 语言架构师 Brian Goetz，曾经写过一篇文章，详尽的说明了并吐槽了Java语言，他和很多程序员一样抱怨“Java太啰嗦”或有太多的“繁文缛节”，他提到：开发人员想要创建纯数据载体类（plain data carriers）通常都必须编写大量低价值、重复的、容易出错的代码。如：构造函数、getter/setter、equals()、hashCode()以及toString()等。以至于很多人选择使用IDE的功能来自动生成这些代码。还有一些开发会选择使用一些第三方类库，如Lombok等来生成这些方法，从而会导致了令人吃惊的表现（surprisingbehavior）和糟糕的可调试性（poor debuggability）。

使用record来减少类声明语法，效果类似 lombok 的 @Data 注解，Kotlin中的dataclass。它们的共同点是类的部分或全部状态可以直接在类头中描述，并且这个类中只包含了纯数据而已。该预览特性提供了一种更为紧凑的语法来声明类。值得一提的是，该特性可以大幅减少定义类似数据类型时所需的样板代码。

Records Class 也是第二次出现的预览功能，它在 JDK 14 中也出现过一次了，使用 Record 可以更方便的创建一个常量类，使用的前后代码对比如下：

//使用record后
public record Customer(String name, Customer partner) {}

//使用record前

class Customer {
    private final String name;
    private final Customer partner;

    public Customer(String name, Customer partner) {
        this.name = name;
        this.partner = partner;
    }

    public String getName() {
        return name;
    }

    public Customer getPartner() {
        return partner;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Customer)) return false;
        Customer customer = (Customer) o;
        return Objects.equals(name, customer.name) && Objects.equals(partner, customer.partner);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, partner);
    }

    @Override
    public String toString() {
        return "Customer1{" +
                "name='" + name + '\'' +
                ", partner=" + partner +
                '}';
    }
}

当你用record 声明一个类时，该类将自动拥有以下功能：
➢ 获取成员变量的简单方法。以上面代码为例 name() 和 partner() ，我们可以通过运行下面的测试类来看看，注意区别于我们平常getter的写法。
➢ 一个 equals 方法的实现，执行比较时会比较该类的所有成员属性
➢ 重写 equals 也重写了 hashCode
➢ 一个可以打印该类所有成员属性的 toString 方法。
➢ 请注意只会有一个构造方法。

测试类如下：

package com.shenzhi.belina.lambda;

import ch.qos.logback.core.net.SyslogOutputStream;
import com.shenzhi.belina.entity.Customer;

import java.util.HashSet;

public class CustomerTest {

    public static void main(String[] args) {

        Customer customer = new Customer("conan", new Customer("chan", null));
        System.out.println(customer.toString());
        System.out.println(customer.name()); // 类似于原有的实例变量的get方法

        HashSet set = new HashSet<>(); // 验证是否重写了equals方法
        Customer customer1 = new Customer("conan", new Customer("chan", null));
        set.add(customer);
        set.add(customer1);
        set.forEach(System.out::println);

    }
}

通过运行上面的测试类，我们就可以看到上述总结的知识点了，不再赘述。

和枚举类型一样，record也是类的一种受限形式。作为回报，记录对象在简洁性方面提供了显著的好处。

➢ 我们还可以在Record声明的类中定义静态字段、静态方法、构造器或实例方法。
➢ 不能在Record声明的类中定义实例字段；类不能声明为abstract；不能声明显式的父类等。

package com.shenzhi.belina.entity;

public record Customer(String name, Customer partner) { // 小括号内定义成员变量

//  还可以声明构造器，静态的变量、方法、实例方法
    public Customer(String name){
        this(name,null);
    }

    public static String info;

    public void show(){
        System.out.println("i am a singer , my name is "+ name());
    }

    public  static  void  shown(){
        System.out.println("my  name is belina");
    }

    //不可以在record中定义实例变量
//    public int id;

    private static Person person;

    public static int id;


}

//record不可以声明为abstract;
//abstract record Employee(){}

//不可以显示的继承于其他类，因为本身已经继承于record
//record Employee() extends Thread{}

特性五：隐藏类（底层优化）

JEP 371:Hidden Classes
 
该提案通过启用标准 API 来定义无法发现且具有有限生命周期的隐藏类，从而提高 JVM 上所有语言的效率。JDK内部和外部的框架将能够动态生成类，而这些类可以定义隐藏类。通常来说基于JVM的很多语言都有动态生成类的机制，这样可以提高语言的灵活性和效率。
隐藏类天生为框架设计的，在运行时生成内部的class。
隐藏类只能通过反射访问，不能直接被其他类的字节码访问。
隐藏类可以独立于其他类加载、卸载，这可以减少框架的内存占用。
 
Hidden Classes是什么呢？
Hidden Classes就是不能直接被其他class的二进制代码使用的class。Hidden Classes主要被一些框架用来生成运行时类，但是这些类不是被用来直接使用的，而是通过反射机制来调用。
比如在JDK8中引入的lambda表达式，JVM并不会在编译的时候将lambda表达式转换成为专门的类，而是在运行时将相应的字节码动态生成相应的类对象。
另外使用动态代理也可以为某些类生成新的动态类。

 
那么我们希望这些动态生成的类需要具有什么特性呢？
不可发现性。因为我们是为某些静态的类动态生成的动态类，所以我们希望把这个动态生成的类看做是静态类的一部分。所以我们不希望除了该静态类之外的其他机制发现。
访问控制。我们希望在访问控制静态类的同时，也能控制到动态生成的类。
生命周期。动态生成类的生命周期一般都比较短，我们并不需要将其保存和静态类的生命周期一致。
 
API的支持
所以我们需要一些API来定义无法发现的且具有有限生命周期的隐藏类。这将提高所有基于JVM的语言实现的效率。
比如：
java.lang.reflect.Proxy可以定义隐藏类作为实现代理接口的代理类。
java.lang.invoke.StringConcatFactory可以生成隐藏类来保存常量连接方法；
java.lang.invoke.LambdaMetaFactory可以生成隐藏的nestmate类，以容纳访问封闭变量的lambda主体；
 
普通类是通过调用ClassLoader::defineClass创建的，而隐藏类是通过调用Lookup::defineHiddenClass创建的。这使JVM从提供的字节中派生一个隐藏类，链接该隐藏类，并返回提供对隐藏类的反射访问的查找对象。调用程序可以通过返回的查找对象来获取隐藏类的Class对象。

特性六：ZGC（底层优化）

JEP 377:ZGC: A Scalable Low-Latency Garbage Collector (Production) 

ZGC是Java 11引入的新的垃圾收集器（JDK9以后默认的垃圾回收器是G1），经过了多个实验阶段，自此终于成为正式特性。
自 2018 年以来，ZGC 已增加了许多改进，从并发类卸载、取消使用未使用的内存、对类数据共享的支持到改进的 NUMA 感知。此外，最大堆大小从 4 TB 增加到 16 TB。支持的平台包括 Linux、Windows 和 MacOS。
 
ZGC是一个重新设计的并发的垃圾回收器，通过减少 GC 停顿时间来提高性能。
 
但是这并不是替换默认的GC，默认的GC仍然还是G1；之前需要通过-XX:+UnlockExperimentalVMOptions -XX:+UseZGC来启用ZGC，现在只需要-XX:+UseZGC就可以。相信不久的将来它必将成为默认的垃圾回收器。
 
相关的参数有ZAllocationSpikeTolerance、ZCollectionInterval、ZFragmentationLimit、ZMarkStackSpaceLimit、ZProactive、ZUncommit、ZUncommitDelay ZGC-specific JFR events(ZAllocationStall、ZPageAllocation、ZPageCacheFlush、ZRelocationSet、ZRelocationSetGroup、ZUncommit)也从experimental变为product
 

2、次要新特性

特性一：EdDSA 数字签名算法（API层面）

JEP 339：Edwards-Curve Digital Signature Algorithm（EdDSA 数字签名算法)
 
这是一个新的功能。
新加入基于Edwards-Curve数字签名算法(EdDSA-Edwards-Curve Digital Signature Algorithm)的加密签名，即爱德华兹曲线数字签名算法。
 
在许多其它加密库（如 OpenSSL 和 BoringSSL）中得到支持。
 
与 JDK 中的现有签名方案相比，EdDSA 具有更高的安全性和性能，因此备受关注。它已经在OpenSSL和BoringSSL等加密库中得到支持，在区块链领域用的比较多。
 
EdDSA是一种现代的椭圆曲线方案，具有JDK中现有签名方案的优点。EdDSA将只在SunEC提供商中实现。

特性二：重新实现 DatagramSocket API（API层面）

JEP 373:Reimplement the Legacy DatagramSocket API(重新实现 DatagramSocket API)
 
新的计划是JEP 353的后续，该方案重新实现了遗留的套接字API。
java.net.datagram.Socket和java.net.MulticastSocket的当前实现可以追溯到JDK 1.0，那时IPv6还在开发中。因此，当前的多播套接字实现尝试调和IPv4和IPv6难以维护的方式。
 
 
通过替换 java.net.datagram 的基础实现，重新实现旧版 DatagramSocket API。
更改java.net.DatagramSocket 和 java.net.MulticastSocket 为更加简单、现代化的底层实现。提高了 JDK 的可维护性和稳定性。
 
通过将java.net.datagram.Socket和java.net.MulticastSocket API的底层实现替换为更简单、更现代的实现来重新实现遗留的DatagramSocket API。
新的实现：1.易于调试和维护;2.与Project Loom中正在探索的虚拟线程协同。
 
 
 特性三：禁用偏向锁定（底层优化）

JEP 374: Disable and Deprecate Biased Locking 禁用偏向锁定
 
在默认情况下禁用偏向锁定，并弃用所有相关命令行选项。目标是确定是否需要继续支持偏置锁定的高维护成本的遗留同步优化，HotSpot虚拟机使用该优化来减少非竞争锁定的开销。尽管某些Java应用程序在禁用偏向锁后可能会出现性能下降，但偏向锁的性能提高通常不像以前那么明显。
 
 
该特性默认禁用了biased locking(-XX:+UseBiasedLocking)，并且废弃了所有相关的命令行选型(BiasedLockingStartupDelay, BiasedLockingBulkRebiasThreshold, BiasedLockingBulkRevokeThreshold, BiasedLockingDecayTime, UseOptoBiasInlining, PrintBiasedLockingStatistics and PrintPreciseBiasedLockingStatistics)

特性四：Shenandoah 垃圾回收算法（底层优化）

Shenandoah垃圾回收算法终于从实验特性转变为产品特性，这是一个从 JDK 12 引入的回收算法，该算法通过与正在运行的 Java 线程同时进行疏散工作来减少 GC 暂停时间。Shenandoah 的暂停时间与堆大小无关，无论堆栈是 200 MB 还是 200 GB，都具有相同的一致暂停时间。
 
怎么形容Shenandoah和ZGC的关系呢？异同点大概如下：
相同点：性能几乎可认为是相同的
不同点：ZGC是Oracle JDK的，根正苗红。而Shenandoah只存在于OpenJDK中，因此使用时需注意你的JDK版本
 
打开方式：使用-XX:+UseShenandoahGC命令行参数打开。
 
Shenandoah在JDK12被作为experimental引入，在JDK15变为Production；之前需要通过-XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC来启用，现在只需要-XX:+UseShenandoahGC即可启用
 

特性五：外部存储器访问 API（API层面）

JEP 383:Foreign-Memory Access API (Second Incubator) 外部存储器访问 API（孵化器版）
目的是引入一个 API，以允许 Java 程序安全、有效地访问 Java 堆之外的外部存储器。如本机、持久和托管堆。
 
有许多Java程序是访问外部内存的，比如Ignite和MapDB。该API将有助于避免与垃圾收集相关的成本以及与跨进程共享内存以及通过将文件映射到内存来序列化和反序列化内存内容相关的不可预测性。该Java API目前没有为访问外部内存提供令人满意的解决方案。但是在新的提议中，API不应该破坏JVM的安全性。
 
Foreign-Memory Access API在JDK14被作为incubating API引入，在JDK15处于Second Incubator，提供了改进。
 

特性六：移除 Solaris 和 SPARC 端口

JEP 381：Remove the Solaris and SPARC Ports (移除 Solaris 和 SPARC 端口)
删除对Solaris/SPARC、Solaris/x64和Linux/SPARC端口的源代码和构建支持，在JDK 14中被标记为废弃，在JDK15版本正式移除。
 
许多正在开发的项目和功能（如Valhalla、Loom和Panama）需要进行重大更改以适应CPU架构和操作系统特定代码。
 
近年来，Solaris 和 SPARC 都已被 Linux 操作系统和英特尔处理器取代。放弃对 Solaris 和 SPARC 端口的支持将使 OpenJDK 社区的贡献者能够加速开发新功能，从而推动平台向前发展。
 

特性七：移除the Nashorn JS引擎

JEP 372：Remove the Nashorn JavaScript Engine 
Nashorn是在JDK提出的脚本执行引擎，该功能是 2014 年 3 月发布的 JDK 8 的新特性。在JDK11就已经把它标记为废弃了，JDK15完全移除。
 
在JDK11中取以代之的是GraalVM。GraalVM是一个运行时平台，它支持Java和其他基于Java字节码的语言，但也支持其他语言，如JavaScript，Ruby，Python或LLVM。性能是Nashorn的2倍以上。
 
JDK15移除了Nashorn JavaScript Engine及jjs 命令行工具。具体就是jdk.scripting.nashorn及jdk.scripting.nashorn.shell这两个模块被移除了。
 
 
补充：

Graal VM在HotSpot VM基础上增强而成的跨语言全栈虚拟机，可以作为“任何语言”的运行平台使用。语言包括：Java、Scala、Groovy、Kotlin；C、C++、JavaScript、Ruby、Python、R等
 

特性八：废弃RMI 激活机制

JEP 385:Deprecate RMI Activation for Removal
 
RMI Activation被标记为Deprecate,将会在未来的版本中删除。RMI激活机制是RMI中一个过时的部分，自Java 8以来一直是可选的而非必选项。RMI激活机制增加了持续的维护负担。RMI的其他部分暂时不会被弃用。
 

在RMI系统中，我们使用延迟激活。延迟激活将激活对象推迟到客户第一次使用（即第一次方法调用）之前。
既然RMI Activation这么好用，为什么要废弃呢？
因为对于现代应用程序来说，分布式系统大部分都是基于Web的，web服务器已经解决了穿越防火墙，过滤请求，身份验证和安全性的问题，并且也提供了很多延迟加载的技术。
所以在现代应用程序中，RMI Activation已经很少被使用到了。并且在各种开源的代码库中，也基本上找不到RMI Activation的使用代码了。
为了减少RMI Activation的维护成本，在JDK8中，RMI Activation被置为可选的。现在在JDK15中，终于可以废弃了。
 

3、次次要新特性

一：添加项

添加项
Support for Unicode 13.0 (JDK-8239383)
升级了Unicode，支持Unicode 13.0
Added isEmpty Default Method to CharSequence (JDK-8215401)
给CharSequence新增了isEmpty方法 java.base/java/lang/CharSequence.java

 
Specialized Implementations of TreeMap Methods (JDK-8176894)
JDK15对TreeMap提供了putIfAbsent, computeIfAbsent, computeIfPresent, compute, merge方法提供了overriding实现
 
New Option Added to jcmd for Writing a gzipped Heap Dump (JDK-8237354)
jcmd的GC.heap_dump命令现在支持gz选型，以dump出gzip压缩版的heap；compression level从1(fastest)到9(slowest, but best compression)，默认为1
 
Added Support for SO_INCOMING_NAPI_ID Support (JDK-8243099)
jdk.net.ExtendedSocketOptions新增了SO_INCOMING_NAPI_ID选型
New System Properties to Configure the TLS Signature Schemes (JDK-8242141)
新增了jdk.tls.client.SignatureSchemes及jdk.tls.server.SignatureSchemes用于配置TLS Signature Schemes
Support for certificate_authorities Extension (JDK-8206925)
支持certificate_authorities的扩展
 

二：移除项&废弃项

移除项
Obsolete -XX:UseAdaptiveGCBoundary (JDK-8228991)
淘汰了-XX:UseAdaptiveGCBoundary
 
废弃项
Deprecated -XX:ForceNUMA Option (JDK-8243628)
废弃了ForceNUMA选项
Disable Native SunEC Implementation by Default (JDK-8237219)
默认禁用了Native SunEC Implementation
 

三：其他事项

已知问题
java.net.HttpClient Does Not Override Protocols Specified in SSLContext Default Parameters (JDK-8239594)
HttpClient现在没有覆盖在SSLContext Default Parameters中指定的Protocols
 
其他事项
DatagramPacket.getPort() Returns 0 When the Port Is Not Set (JDK-8237890)
当DatagramPacket没有设置port的时候，其getPort方法返回0
Improved Ergonomics for G1 Heap Region Size (JDK-8241670)
优化了默认G1 Heap Region Size的计算
 

4、下期预告和参考文献

这篇文章从动笔到结束整整花了两个星期，絮絮叨叨给大家讲了这么多，喜欢你们能喜欢；接下来预计会再用两篇文章，来详细讲讲Java8到Java14的新特性，欢迎收藏、关注、转发、点赞、评论哟，下期再见，比心！！！

由于笔者才疏学浅，创刊伊始，思虑不足，又限于资料来源有限，如有纰漏之处，敬请指正、补充！

参考资料链接：

OpenJDK

Java15新特性教程

Java版本历史