jdk1.5-1.10新特性

Posted 2021-02-05 chaoqun

从网上搜集摘录的jdk特性,在这里记录下来以便自我学习.

jdk5新特性
    1、自动装箱和拆箱
    2、枚举
    3、静态导入
    4、可变参数
    5、內省
       是Java语言对Bean类属性、事件的一种缺省处理方法。例如类A中有属性那么，那我们可以通过getName，setName来得到其值或者设置新的值。通过getName/setName来访问name属性，这就是默认的规则。Java中提供了一套API用来访问某个属性的getter，setter方法，通过这些API可以使你不需要了解这个规则，这些API存放于包java.beans中。
       一般的做法是通过类Introspector来获取某个对象的BeanInfo信息，然后通过BeanInfo来获取属性的描述器（PropertyDescriptor），通过这个属性描述器就可以获取某个属性对应的getter/setter方法，然后我们就可以通过反射机制来调用这些方法。
    6、泛型
    7、For-Each循环

jdk6新特性
    1、Desktop类和SystemTray类
       AWT新增加了两个雷：Desktop，SystemTray。
       Desktop可以用来打开系统默认浏览器指定的URL，打开系统默认邮件客户端给指定的邮件账号发邮件，用默认应用程序打开或编辑文件（比如，用记事本打开txt文件），用系统默认的打印机打印文档
       SystemTray可以用来在系统托盘区创建一个托盘程序
    2、使用JAXB2来实现对象与XML之间的映射
       也就是对象与XML之间的映射（OXM），也可以通过XMLBeans和Castor等来实现同样的功能。
    3、StAX
       StAX是The Streaming API for XML的缩写，一种利用拉模式解析(pull-parsing)XML文档的API.StAX通过提供一种基于事件迭代器(Iterator)的API让 程序员去控制xml文档解析过程,程序遍历这个事件迭代器去处理每一个解析事件，解析事件可以看做是程序拉出来的，也就是程序促使解析器产生一个解析事件 然后处理该事件，之后又促使解析器产生下一个解析事件，如此循环直到碰到文档结束符； 
                SAX也是基于事件处理xml文档，但却 是用推模式解析，解析器解析完整个xml文档后，才产生解析事件，然后推给程序去处理这些事件；DOM 采用的方式是将整个xml文档映射到一颗内存树，这样就可以很容易地得到父节点和子结点以及兄弟节点的数据，但如果文档很大，将会严重影响性能。
    4、使用Compiler API
                使用JDK6的Compiler API去动态的编译Java源文件，Compiler API结合反射功能就可以实现动态的产生Java代码并编译执行这些代码。
    5、轻量级Http Server API
    6、插入式注解处理API
    7、用Console开发控制台程序
    8、对脚本语言的支持如：ruby，groovy，javascript
    9、Common Annotations

jdk7新特性
    1、switch中可以使用字符串
    2、泛型的自动判断
    3、自定义自动关闭类（实现AutoCloseable接口）
    4、新增一些取环境信息的工具方法（System中的方法）
    5、Boolean类型反转，空指针安全，参数与位运算
    6、两个char间的equals
    7、安全的加减乘除

    1、对Java集合（Collections）的增强支持
       List<String> list=["item"]; //向List集合中添加元素
       String item=list[0]; //从List集合中获取元素
       Set<String> set={"item"}; //向Set集合对象中添加元
       Map<String,Integer> map={"key":1}; //向Map集合中添加对象
       int value=map["key"]; //从Map集合中获取对象
       但是经过自己测试，按照上面的使用方法，并不能创建集合。
    2、int支持二进制数据
    3、在try catch异常捕捉中，一个catch可以写多个异常类型
    Connection conn = null;
    try {
        Class.forName("com.mysql.jdbc.Driver");
        conn = DriverManager.getConnection("","","");
    } catch(ClassNotFoundException|SQLException ex) {
        ex.printStackTrace();
    }
    4、try catch中资源定义好之后try catch自动关闭
    try (BufferedReader in  = new BufferedReader(new FileReader("in.txt"));
         BufferedWriter out = new BufferedWriter(new FileWriter("out.txt"))) {
    int charRead;
    while ((charRead = in.read()) != -1) {
            System.out.printf("%c ", (char)charRead);
            out.write(charRead);
        }
    } catch (IOException ex) {
        ex.printStackTrace();
    }
jdk8新特性
    1、接口的默认方法
    Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用default关键字即可，这个特征又叫做扩展方法，示例如下：
    public interface Formula {
        double calculate(int a);
        default double sqrt(int a) {
    return Math.sqrt(a);
        }
    }
    Formula接口在拥有calculate方法之外同时还定义了sqrt方法，实现了Formula接口的子类只需要实现一个calculate方法，默认方法sqrt将在子类上可以直接使用。
        Formula formula = new Formula() {
    @Override
    public double calculate(int a) {
    return sqrt(a * 100);
            }
        };
        System.out.println(formula.calculate(100));  // 100.0
        System.out.println(formula.sqrt(16));  // 4.0
    文中的formula被实现为一个匿名类的实例，该代码非常
    2、Lambda表达式
    List<String> names = Arrays.asList("tom","jace","mike");
    Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
    return o2.compareTo(o1);
        }
    });
    只需要给静态方法Collections.sort传入一个List对象以及一个比较器来指定顺序排列。通常做法都是创建一个匿名的比较器对象，然后将其传递给sort方法。
    在Java 8中提供了更简洁的语法，lambda表达式：
    Collections.sort(names, (String a, String b) -> {
    return b.compareTo(a);
    });
    还可以更简洁：
    Collections.sort(names, (String a, String b) -> b.compareTo(a));
    去掉大括号以及return关键字
    Collections.sort(names, (a,b) -> b.compareTo(a));
    Java编译器可以自动推导出参数类型，所以可以不用再写一次类型。
    3、函数式接口
    Lambda表达式是如何在java的类型系统中表示的呢？
    每一个lambda表达式都对应着一个类型，通常是接口类型。而“函数式接口”是指仅仅只包含一个抽象方法的接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法。因为默认方法不算抽象方法，所以也可以给自己的函数式接口添加默认方法。
    我们可以将lambda表达式当做一个抽象方法的接口类型，确保自己的接口一定达到这个要求，你只需要给你的接口添加@FunctionalInterface注解，编译器如果发现标注了这个注解的接口有多于一个抽象方法的时候就会报错。也就是说@ FunctionalInterface注解标注的接口只能有一个抽象方法。
    例如：
    @FunctionalInterface
    public interface Converter<F, T> {
    T convert(F from);
    }
    Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
    Integer converted = converter.convert("123");
    System.out.println(converted);
    以上代码不需要@FunctionalInterface注解也是正确的。
    4、方法与构造函数引用
    上面的代码也可以通过静态方法引用来表示：
    Converter<String, Integer> converter = Integer::valueOf;
    Integer converted = converter.convert("123");
    System.out.println(converted);
    Java8允许使用::关键字来传递方法或者构造函数引用，上面的代码展示了如何引用一个静态方法，我们也可以引用一个对象的方法：
    public class Person {
        String firstName;
        String lastName;
        Person() {
        }
    public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
        }
    }
    指定一个用来创建Person对象的对象工厂接口：
    public interface PersonFactory<P extends Person> {
    P create(String fisrtName, String lastName);
    }
    创建Person对象
    PersonFactory<Person> personFactory = Person::new;
    Person person = personFactory.create("Peter","Parker”);
    我们只需要使用Person::new 来获取Person类构造函数的引用，Java编译器就会自动根据PersonFactory.create方法的签名来选择合适的构造函数。
    5、Lambda作用域
    在lambda表达式中访问外层作用域和老版本的匿名对象中的方式很相似。你可以直接访问标记了final的外层局部变量，或者实例的字段以及静态变量。
    6、访问局部变量
    我们可以直接在lambda表达式中访问外层的局部变量
    final int num = 1;
    Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num);
    stringConverter.convert(2);
    但是和匿名对象不同的是，这里的变量num可以不用声明为final，该代码同样正确。
    7、访问对象字段与静态变量
    和本地不良不同的是，lambda内部对于实例的字段以及静态变量是即可读又可写。该行为和匿名对象是一致的：
    static int outerStaticNum;
    int outerNum;
    public void testScopes() {
        Converter stringConverter1 = (from) -> {
            outerNum = 23;
            return String.valueOf(from);
        };
        Converter stringConverter2 = (from) -> {
            outerStaticNum = 72;
            return String.valueOf(from);
        };
    }
    8、访问接口的默认方法
    9、Date API
    10、Annotation注解
    11.HashMap
    HashMap中的红黑树:HashMap中链长度大于8时采取红黑树的结构存储。红黑树，除了添加的情况外，其他时候效率高于链表结构。
    ConcurrentHashMap:底层采用node数组+链表+红黑树的存储结构，通过CAS算法(乐观锁机制)+synchronized来保证并发安全的实现。
    put（）方法过程：
    1) 根据key的hash值数组中相应位置的Node还未初始化，则通过CAS插入相应的数据；
    2) 如果相应位置的Node不为空，且当前该节点不处于移动状态，则对该节点加synchronized锁，如果该节点的hash不小于0，则遍历链表更新节点或插入新节点；
    3) 如果该节点是TreeBin类型的节点，说明是红黑树结构，则通过putTreeVal方法往红黑树中插入节点；
    
jdk1.9新特性
    1. Java 平台级模块系统
    Java 9 的定义功能是一套全新的模块系统。当代码库越来越大，创建复杂，盘根错节的“意大利面条式代码”的几率呈指数级的增长。这时候就得面对两个基础的问题: 很难真正地对代码进行封装, 而系统并没有对不同部分（也就是 JAR 文件）之间的依赖关系有个明确的概念。每一个公共类都可以被类路径之下任何其它的公共类所访问到, 这样就会导致无意中使用了并不想被公开访问的 API。此外，类路径本身也存在问题: 你怎么知晓所有需要的 JAR 都已经有了, 或者是不是会有重复的项呢? 模块系统把这俩个问题都给解决了。

    模块化的 JAR 文件都包含一个额外的模块描述器。在这个模块描述器中, 对其它模块的依赖是通过 “requires” 来表示的。另外, “exports” 语句控制着哪些包是可以被其它模块访问到的。所有不被导出的包默认都封装在模块的里面。如下是一个模块描述器的示例，存在于 “module-info.java” 文件中:

    module blog {
      exports com.pluralsight.blog;
     
      requires cms;
    }
    我们可以如下展示模块：

    请注意，两个模块都包含封装的包，因为它们没有被导出（使用橙色盾牌可视化）。 没有人会偶然地使用来自这些包中的类。Java 平台本身也使用自己的模块系统进行了模块化。通过封装 JDK 的内部类，平台更安全，持续改进也更容易。

    当启动一个模块化应用时， JVM 会验证是否所有的模块都能使用，这基于 `requires` 语句——比脆弱的类路径迈进了一大步。模块允许你更好地强制结构化封装你的应用并明确依赖。你可以在这个课程中学习更多关于 Java 9 中模块工作的信息 。

    2. Linking
    当你使用具有显式依赖关系的模块和模块化的 JDK 时，新的可能性出现了。你的应用程序模块现在将声明其对其他应用程序模块的依赖以及对其所使用的 JDK 模块的依赖。为什么不使用这些信息创建一个最小的运行时环境，其中只包含运行应用程序所需的那些模块呢？ 这可以通过 Java 9 中的新的 jlink 工具实现。你可以创建针对应用程序进行优化的最小运行时映像而不需要使用完全加载 JDK 安装版本。

    3. JShell : 交互式 Java REPL
    许多语言已经具有交互式编程环境，Java 现在加入了这个俱乐部。您可以从控制台启动 jshell ，并直接启动输入和执行 Java 代码。 jshell 的即时反馈使它成为探索 API 和尝试语言特性的好工具。

    测试一个 Java 正则表达式是一个很好的说明 jshell 如何使您的生活更轻松的例子。 交互式 shell 还可以提供良好的教学环境以及提高生产力，您可以在此了解更多信息。在教人们如何编写 Java 的过程中，不再需要解释 “public static void main（String [] args）” 这句废话。

    4. 改进的 Javadoc
    有时一些小事情可以带来很大的不同。你是否就像我一样在一直使用 Google 来查找正确的 Javadoc 页面呢？ 这不再需要了。Javadoc 现在支持在 API 文档中的进行搜索。另外，Javadoc 的输出现在符合兼容 html5 标准。此外，你会注意到，每个 Javadoc 页面都包含有关 JDK 模块类或接口来源的信息。

    5. 集合工厂方法
    通常，您希望在代码中创建一个集合（例如，List 或 Set ），并直接用一些元素填充它。 实例化集合，几个 “add” 调用，使得代码重复。 Java 9，添加了几种集合工厂方法：

    Set<Integer> ints = Set.of(1, 2, 3);
    List<String> strings = List.of("first", "second");
    除了更短和更好阅读之外，这些方法也可以避免您选择特定的集合实现。 事实上，从工厂方法返回已放入数个元素的集合实现是高度优化的。这是可能的，因为它们是不可变的：在创建后，继续添加元素到这些集合会导致 “UnsupportedOperationException” 。

    6. 改进的 Stream API
    长期以来，Stream API 都是 Java 标准库最好的改进之一。通过这套 API 可以在集合上建立用于转换的申明管道。在 Java 9 中它会变得更好。Stream 接口中添加了 4 个新的方法：dropWhile, takeWhile, ofNullable。还有个 iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代：

    IntStream.iterate(1, i -> i < 100, i -> i + 1).forEach(System.out::println);
    第二个参数是一个 Lambda，它会在当前 IntStream 中的元素到达 100 的时候返回 true。因此这个简单的示例是向控制台打印 1 到 99。

    除了对 Stream 本身的扩展，Optional 和 Stream 之间的结合也得到了改进。现在可以通过 Optional 的新方法 `stram` 将一个 Optional 对象转换为一个(可能是空的) Stream 对象：

    Stream<Integer> s = Optional.of(1).stream();
    在组合复杂的 Stream 管道时，将 Optional 转换为 Stream 非常有用。

    7. 私有接口方法
    Java 8 为我们带来了接口的默认方法。 接口现在也可以包含行为，而不仅仅是方法签名。 但是，如果在接口上有几个默认方法，代码几乎相同，会发生什么情况？ 通常，您将重构这些方法，调用一个可复用的私有方法。 但默认方法不能是私有的。 将复用代码创建为一个默认方法不是一个解决方案，因为该辅助方法会成为公共API的一部分。 使用 Java 9，您可以向接口添加私有辅助方法来解决此问题：

    public interface MyInterface {
     
        void normalInterfaceMethod();
     
        default void interfaceMethodWithDefault() {  init(); }
     
        default void anotherDefaultMethod() { init(); }
     
        // This method is not part of the public API exposed by MyInterface
        private void init() { System.out.println("Initializing"); }
    }
    如果您使用默认方法开发 API ，那么私有接口方法可能有助于构建其实现。

    8. HTTP/2
    Java 9 中有新的方式来处理 HTTP 调用。这个迟到的特性用于代替老旧的 `HttpURLConnection` API，并提供对 WebSocket 和 HTTP/2 的支持。注意：新的 HttpClient API 在 Java 9 中以所谓的孵化器模块交付。也就是说，这套 API 不能保证 100% 完成。不过你可以在 Java 9 中开始使用这套 API：

    HttpClient client = HttpClient.newHttpClient();
     
    HttpRequest req =
       HttpRequest.newBuilder(URI.create("http://www.google.com"))
                  .header("User-Agent","Java")
                  .GET()
                  .build();
     
     
    HttpResponse<String> resp = client.send(req, HttpResponse.BodyHandler.asString());
    HttpResponse<String> resp = client.send(req, HttpResponse.BodyHandler.asString());
    除了这个简单的请求/响应模型之外，HttpClient 还提供了新的 API 来处理 HTTP/2 的特性，比如流和服务端推送。

    9. 多版本兼容 JAR
    我们最后要来着重介绍的这个特性对于库的维护者而言是个特别好的消息。当一个新版本的 Java 出现的时候，你的库用户要花费数年时间才会切换到这个新的版本。这就意味着库得去向后兼容你想要支持的最老的 Java 版本 (许多情况下就是 Java 6 或者 7)。这实际上意味着未来的很长一段时间，你都不能在库中运用 Java 9 所提供的新特性。幸运的是，多版本兼容 JAR 功能能让你创建仅在特定版本的 Java 环境中运行库程序时选择使用的 class 版本：

    multirelease.jar
    ├── META-INF
    │   └── versions
    │       └── 9
    │           └── multirelease
    │               └── Helper.class
    ├── multirelease
        ├── Helper.class
        └── Main.class
    在上述场景中， multirelease.jar 可以在 Java 9 中使用, 不过 Helper 这个类使用的不是顶层的 multirelease.Helper 这个 class, 而是处在“META-INF/versions/9”下面的这个。这是特别为 Java 9 准备的 class 版本，可以运用 Java 9 所提供的特性和库。同时，在早期的 Java 诸版本中使用这个 JAR 也是能运行的，因为较老版本的 Java 只会看到顶层的这个 Helper 类。

jdk1.10新特性
    1.局部变量类型推断:局部变量类型推断将引入"var"关键字，也就是你可以随意定义变量而不必指定变量的类型.
    原本需要这样：  
    List <String> list = new ArrayList <String>（）; 
    Stream <String> stream = getStream（）;
     
    现在你可以这样：
     
    var list = new ArrayList <String>（）; 
    var stream = getStream（）;
     
    说到类型推断，从JDK 5引进泛型，到JDK 7的"<>"操作符允许不绑定类型而初始化List，再到JDK 8的Lambda表达式，再到现在JDK 10的局部变量类型推断，Java类型推断正大刀阔斧的向前发展。
    2.GC改进和内存管理

    JDK 10中有2个JEP专门用于改进当前的垃圾收集元素。
     
    第一个垃圾收集器接口是（JEP 304），它将引入一个纯净的垃圾收集器接口，以帮助改进不同垃圾收集器的源代码隔离。
     
    预定用于Java 10的第二个JEP是针对G1的并行完全GC（JEP 307），其重点在于通过完全GC并行来改善G1最坏情况的等待时间。G1是Java 9中的默认GC，并且此JEP的目标是使G1平行。
    3.线程本地握手（JEP 312）

    JDK 10将引入一种在线程上执行回调的新方法，因此这将会很方便能停止单个线程而不是停止全部线程或者一个都不停。
    4.备用内存设备上的堆分配（JEP 316）

    允许HotSpot VM在备用内存设备上分配Java对象堆内存，该内存设备将由用户指定。
    5.其他Unicode语言 - 标记扩展（JEP 314）

    目标是增强java.util.Locale及其相关的API，以便实现语言标记语法的其他Unicode扩展（BCP 47）。
    6.基于Java的实验性JIT编译器

    Oracle希望将其Java JIT编译器Graal用作Linux / x64平台上的实验性JIT编译器。
    7.根证书（JEP 319）

    这个的目标是在Oracle的Java SE中开源根证书。
    8.根证书颁发认证（CA）

    这将使OpenJDK对开发人员更具吸引力，它还旨在减少OpenJDK和Oracle JDK构建之间的差异。
    9.将JDK生态整合单个存储库（JEP 296）

    此JEP的主要目标是执行一些内存管理，并将JDK生态的众多存储库组合到一个存储库中。
    10.删除工具javah（JEP 313）

    从JDK中移除了javah工具，这个很简单并且很重要。