怎么替换java版本

转载

lanhy 2024-10-29 15:05:51

文章标签 怎么替换java版本编程语言 java API Java 文章分类 Java 后端开发

JDK

JDK1.5的特性

1.概述
2.新特性

(1)泛型
(2)For-Each循环
(3)自动"装箱"(Autoboxing)/"拆箱"(Unboxing)
(4)枚举(Enums)
(5)可变参数(Varargs)
(6)静态导入

JDK1.6

1.增强for循环
2.监视和管理
3.插入式注解处理
4.安全性
5.DestTop类和SystemTray类
6.使用JAXB2来实现对象与XML之间的映射
7.StAX
8.使用Complier API
9.轻量级的Http Server API
10.插入式注解处理API(Pluggable Annotation Processing API)
11.用Console开发控制台程序
12.对脚本语言的支持
13.Common Annotations

JDK1.7

1.在Switch中可以用String字符串
2.Try-with-resource语句
3.Catch支持多个异常
4.泛型实例的创建可以通过类型推断来简化
5.在可变参数方法中传递非具体化参数,改进编译警告和错误
6.支持二进制数字
7.数值可以加下划线用作分隔符
8.简化了可变参数方法的调用
9.新增加了Objects类

JDK1.8

概述
特性

1.Lambda 表达式
2.方法引用
3.函数式接口
4.默认方法
5.Stream API
6.Date Time API
7.Optional 类
8.Nashorn, JavaScript 引擎
9.Base64

Java 1.9

概述
新特性

1.模块系统：模块是一个包的容器，Java 9 最大的变化之一是引入了模块系统（Jigsaw 项目）。
2.REPL (JShell)：交互式编程环境。
3.HTTP 2 客户端：HTTP/2标准是HTTP协议的最新版本，新的 HTTPClient API 支持 WebSocket 和 HTTP2 流以及服务器推送特性。
4.改进的 Javadoc：Javadoc 现在支持在 API 文档中的进行搜索。另外，Javadoc 的输出现在符合兼容 HTML5 标准。
5.多版本兼容 JAR 包：多版本兼容 JAR 功能能让你创建仅在特定版本的 Java 环境中运行库程序时选择使用的 class 版本。
6.集合工厂方法：List，Set 和 Map 接口中，新的静态工厂方法可以创建这些集合的不可变实例。
7.私有接口方法：在接口中使用private私有方法。我们可以使用 private 访问修饰符在接口中编写私有方法。
8.进程 API: 改进的 API 来控制和管理操作系统进程。引进 java.lang.ProcessHandle 及其嵌套接口 Info 来让开发者逃离时常因为要获取一个本地进程的 PID 而不得不使用本地代码的窘境。
9.改进的 Stream API：改进的 Stream API 添加了一些便利的方法，使流处理更容易，并使用收集器编写复杂的查询。
10.改进 try-with-resources：如果你已经有一个资源是 final 或等效于 final 变量,您可以在 try-with-resources 语句中使用该变量，而无需在 try-with-resources 语句中声明一个新变量。
11.改进的弃用注解 @Deprecated：注解 @Deprecated 可以标记 Java API 状态，可以表示被标记的 API 将会被移除，或者已经破坏。
12.改进钻石操作符(Diamond Operator) ：匿名类可以使用钻石操作符(Diamond Operator)。
13.改进 Optional 类：java.util.Optional 添加了很多新的有用方法，Optional 可以直接转为 stream。
14.多分辨率图像 API：定义多分辨率图像API，开发者可以很容易的操作和展示不同分辨率的图像了。
15.改进的 CompletableFuture API ： CompletableFuture 类的异步机制可以在 ProcessHandle.onExit 方法退出时执行操作。
16.轻量级的 JSON API：内置了一个轻量级的JSON API
17.响应式流（Reactive Streams) API: Java 9中引入了新的响应式流 API 来支持 Java 9 中的响应式编程。
附图

JDK1.5的特性

1.概述

"JDK1.5"的一个重要主题就是通过新增一些特性来简化开发，这些特性包括泛型，for-each 循环，自动装包/拆包，枚举，可变参数, 静态导入。使用这些特性有助于我们编写更加清晰，精悍，安全的代码。

2.新特性

(1)泛型

1>可以约束集合中元素的类型
2>可以自动完成强制类型转换
3>集合<类型> Collection表示集合中只能存储String类型数据，其他类型不存储

Collection c = new ArrayList();
//泛型  存放整型数据
Collection<Integer> c = new ArrayList<Integer>();

(2)For-Each循环

For-Each循环的加入简化了集合的遍历。

(3)自动"装箱"(Autoboxing)/“拆箱”(Unboxing)

自动装包：基本类型自动转为包装类.(int >> Integer)
自动拆包：包装类自动转为基本类型.(Integer >> int)
1>自动"装箱"和"拆箱"是依靠JDK1.5的编译器在编译期的"预处理"工作
代码：

Integer a = 100 ; //装箱
Integer b = 200 ; //装箱
Integer c = a + b ; //拆箱再装箱
double d = c ;    //拆箱

2>装箱和拆箱是"编译器"认可的，而不是虚拟机。编译器在生成类的字节码时插入必要的方法调用。
代码：

Integer a = 100 => Integer a = Integer.valueOf(100);
Integer b = 200 => Integer b = Integer.valueOf(200);
Integer c = a + b => Integer c = Integer.valueOf(a.intValue()+b.intValue());
Integer d = c => int d = c.intValue();

(4)枚举(Enums)

1>JDK1.5加入了一个全新类型的“类”－枚举类型。为此JDK1.5引入了一个新关键字enmu. 我们可以这样来定义一个枚举类型。
代码：

public enum Color
{
	Red,White,Blue
}

2>枚举类型还提供了两个有用的静态方法values()和valueOf(). 我们可以很方便地使用它们，例如
代码：

for (Color c : Color.values())
System.out.println(c);

(5)可变参数(Varargs)

1>可以声明一个接受可变数目参数的方法。注意，可变参数必须是函数声明中的最后一个参数。
代码：

util.write(obj1);
util.write(obj1,obj2);
util.write(obj1,obj2,obj3);

2>在JDK1.5之前，我们可以用重载来实现，但是这样就需要写很多的重载函数，显得不是很有效。如果使用可变参数的话我们只需要一个函数就行了
代码：

public void write(Object... objs) {
	for (Object obj: objs)
	System.out.println(obj);
}

(6)静态导入

要使用用静态成员（方法和变量）我们必须给出提供这个方法的类。使用静态导入可以使被导入类的所有静态变量和静态方法在当前类直接可见，使用这些静态成员无需再给出他们的类名。

JDK1.6

1.增强for循环

增强for循环也可以遍历集合
代码如下：

for(元素 : 集合) {}
Collection<Double> r = new ArrayList<>();
r.add(3.35);
r.add(6.36);
r.add(null);
r.add(9.36);
r.add(9.365);
Iterator<Double> q = r.iterator();
for(Iterator<Double> q1 = r.iterator();q1.hasNext();){
	Double s = q1.next();
	if(s == null) continue ;
	System.out.println(s);
}
for(Double e : r) {
//会将q1中的每个元素赋值到变量e
System.out.println(e);		
}

上述for(Double e : r)的工作原理：

java编译器在编译时自动会替换为如下语句
for(Iterator q1 = r.iterator();q1.hasNext()😉{
Double s = q1.next();
}
可以将增强for循环看做是一个简化版的“迭代器遍历”

2.监视和管理

Java SE 6中对内存泄漏增强了分析以及诊断能力。当遇到java.lang.OutOfMemory异常的时候，可以得到一个完整的堆栈信息，
并且当堆已经满了的时候，会产生一个Log文件来记录这个致命错误。另外，JVM还添加了一个选项，允许你在堆满的时候运行脚本。

3.插入式注解处理

插入式注解处理API(JSR 269)提供一套标准API来处理Annotations

4.安全性

5.DestTop类和SystemTray类

前者用于调度操作系统中的一些功能，例如：
1> 可以打开系统默认浏览器指定的URL地址；
2> 打开系统默认邮件客户端给指定的邮箱发信息；
3> 用默认程序打开或编辑文件；
4>用系统默认的打印机打印文档。
后者可用来在系统托盘区创建一个托盘程序。

6.使用JAXB2来实现对象与XML之间的映射

JAXB是Java Architecture for XML Binding的缩写，可以将一个Java对象转变成为XML格式，反之亦然。我们把对象与关系数据库之间的映射称为ORM, 其实也可以把对象与XML之间的映射称为OXM(Object XML Mapping). 原来JAXB是Java EE的一部分，在JDK6中，SUN将其放到了Java SE中，这也是SUN的一贯做法。JDK6中自带的这个JAXB版本是2.0, 比起1.0(JSR 31)来，JAXB2(JSR 222)用JDK5的新特性Annotation来标识要作绑定的类和属性等，这就极大简化了开发的工作量。实际上，在Java EE 5.0中，EJB和Web Services也通过Annotation来简化开发工作。另外,JAXB2在底层是用StAX(JSR 173)来处理XML文档。

7.StAX

StAX是JDK1.6中除了DOM和SAX之外的又一种处理XML文档的API。
StAX是The Streaming API for XML的缩写。由于JDK6.0中的JAXB2和JAX-WS 2.0都会用到StAX，所以Sun决定把StAX加入到JAXP家族当中来，并将JAXP的版本升级到1.4.
JDK6里面JAXP的版本就是1.4。JAXP是Java API for XML Processing的英文字头缩写,中文含义是:用于XML文档处理的使用Java语言编写的编程接口。

8.使用Complier API

现在我们可以用JDK1.6 的Compiler API动态编译Java源文件，Compiler API结合反射功能就可以实现动态的产生Java代码并编译执行这些代码，有点动态语言的特征。
这个特性对于某些需要用到动态编译的应用程序相当有用，比如JSP Web Server，当我们手动修改JSP后，是不希望需要重启Web Server才可以看到效果的，这时候我们就可以用Compiler API来实现动态编译JSP文件。

9.轻量级的Http Server API

JDK6 提供了一个简单的Http Server API,据此我们可以构建自己的嵌入式Http Server,它支持Http和Https协议,提供了HTTP1.1的部分实现，没有被实现的那部分可以通过扩展已有的Http Server API来实现,程序员必须自己实现HttpHandler接口,HttpServer会调用HttpHandler实现类的回调方法来处理客户端请求,在这里,我们把一个Http请求和它的响应称为一个交换,包装成HttpExchange类,HttpServer负责将HttpExchange传给 HttpHandler实现类的回调方法。

10.插入式注解处理API(Pluggable Annotation Processing API)

JSR （JSR是Java Specification Requests的缩写，意思是Java 规范请求）用Annotation Processor在编译期间而不是运行期间处理Annotation, Annotation Processor相当于编译器的一个插件,所以称为插入式注解处理。

11.用Console开发控制台程序

JDK6中提供了java.io.Console 类专用来访问基于字符的控制台设备. 你的程序如果要与Windows下的cmd或者Linux下的Terminal交互,就可以用Console类代劳。

12.对脚本语言的支持

JDK6增加了对脚本语言的支持(JSR 223)，原理上是将脚本语言编译成bytecode，这样脚本语言也能享用Java平台的诸多优势，包括可移植性，安全等，另外，由于现在是编译成bytecode后再执行，所以比原来边解释边执行效率要高很多。加入对脚本语言的支持后，对Java语言也提供了以下好处。
1、许多脚本语言都有动态特性，比如，你不需要用一个变量之前先声明它，你可以用一个变量存放完全不同类型的对象，你不需要做强制类型转换，因为转换都是自动的。现在Java语言也可以通过对脚本语言的支持间接获得这种灵活性。
2、可以用脚本语言快速开发产品原型，因为现在可以Edit-Run，而无需Edit-Compile-Run，当然，因为Java有非常好的IDE支持，我们完全可以在IDE里面编辑源文件，然后点击运行(隐含编译)，以此达到快速开发原型的目的，所以这点好处基本上可以忽略。
3、通过引入脚本语言可以轻松实现Java应用程序的扩展和自定义，我们可以把原来分布在在Java应用程序中的配置逻辑，数学表达式和业务规则提取出来，转用JavaScript来处理。

13.Common Annotations

Common annotations原本是Java EE 5.0规范的一部分，现在SUN把它的一部分放到了Java SE 6.0中. 随着Annotation元数据功能加入到Java SE 5.0里面，很多Java 技术(比如EJB,Web Services)都会用Annotation部分代替XML文件来配置运行参数，保证Java SE和Java EE 各种技术的一致性.。

JDK1.7

1.在Switch中可以用String字符串

在1.6的版本switch的参数中只支持byte、short、char、int、long以及他们的包装类（自动拆箱和自动装箱的支持下），然后在jdk1.7支持了String作为参数。

String str = "1";
      switch (str){
          case "1":
              System.out.println("NO.1");
              break;
          case "2":
              System.out.println("NO.2");
              break;
          case "3":
              System.out.println("NO.3");
              break;
              default:
                  System.out.println("fail");
      }

2.Try-with-resource语句

实现java.long.AutoCloseable接口的资源都可以放到try中
跟final里面的关闭资源类似；
按照声明逆序关闭资源；
Try块抛出的异常Throwable.getSuppressed获取。
如果try代码块和try-with-resources语句同时抛出异常，这个方法将会最终抛出try代码块里面的异常，try-with-resources语句里面抛出的异常被压抑了。

public static void writeToFileZipFileContents(String zipFileName,
                                          String outputFileName)
                                          throws java.io.IOException {

    java.nio.charset.Charset charset =
        java.nio.charset.StandardCharsets.US_ASCII;
    java.nio.file.Path outputFilePath =
        java.nio.file.Paths.get(outputFileName);

    // Open zip file and create output file with
    // try-with-resources statement

    try (
        java.util.zip.ZipFile zf =
            new java.util.zip.ZipFile(zipFileName);
        java.io.BufferedWriter writer =
            java.nio.file.Files.newBufferedWriter(outputFilePath, charset)
    ) {
        // Enumerate each entry
        for (java.util.Enumeration entries =
                                zf.entries(); entries.hasMoreElements();) {
            // Get the entry name and write it to the output file
            String newLine = System.getProperty("line.separator");
            String zipEntryName =
                ((java.util.zip.ZipEntry)entries.nextElement()).getName() +
                newLine;
            writer.write(zipEntryName, 0, zipEntryName.length());
        }
    }
}```
在这个例子中，try-with-resources语句包含了两个用分号隔开的声明：ZipFile和BufferedWriter。当代码块中代码终止，不管是正常还是异常，BufferedWriter和ZipFile对象的close方法都会自动按声明的相反顺序调用。

下面的例子用try-with-resources语句自动关闭一个java.sql.Statement对象：

```java
public static void viewTable(Connection con) throws SQLException {

    String query = "select COF_NAME, SUP_ID, PRICE, SALES, TOTAL from COFFEES";

    try (Statement stmt = con.createStatement()) {
        ResultSet rs = stmt.executeQuery(query);

        while (rs.next()) {
            String coffeeName = rs.getString("COF_NAME");
            int supplierID = rs.getInt("SUP_ID");
            float price = rs.getFloat("PRICE");
            int sales = rs.getInt("SALES");
            int total = rs.getInt("TOTAL");

            System.out.println(coffeeName + ", " + supplierID + ", " +
                              price + ", " + sales + ", " + total);
        }
    } catch (SQLException e) {
        JDBCTutorialUtilities.printSQLException(e);
    }
}

3.Catch支持多个异常

public static void main(String[] args) throws Exception {
        try {
        testthrows();
        } catch (IOException | SQLException ex) {
        throw ex;
            }
        }
    public static void testthrows() throws IOException, SQLException {
    }

4.泛型实例的创建可以通过类型推断来简化

可以去掉后面new部分的泛型类型，只用<>就可以了。

新特性之前：

    List strList = new ArrayList(); 
    List<String> strList = new ArrayList<String>(); 
    List<Map<String, List<String>>> strList5 =  new ArrayList<Map<String, List<String>>>();
新特性：
    List<String> strList2 = new ArrayList<>(); 
    List<Map<String, List<String>>> strList3 = new ArrayList<>();
    List<String> list = new ArrayList<>();

5.在可变参数方法中传递非具体化参数,改进编译警告和错误

Heap pollution 指一个变量被指向另外一个不是相同类型的变量。例如

List l = new ArrayList<Number>();
    List<String> ls = l;       // unchecked warning
    l.add(0, new Integer(42)); // another unchecked warning
    String s = ls.get(0);      // ClassCastException is thrown
    Jdk7:
    public static <T> void addToList (List<T> listArg, T... elements) {
    for (T x : elements) {
    listArg.add(x);
    }
    }

6.支持二进制数字

所有整数int、short、long、byte都可以用二进制表示,表示的方法就是在二进制数字前面加上0b.

byte  num1 = 0b00001001;  //1个字节8位
  short num2 =  0b0010000101000101; //2个字节16位
  int   num3 =  0b10100001010001011010000101000101;; //4个字节32位
  long  num4 = 0b0010000101000101101000010100010110100001010001011010000101000101L;//8个字节64位

        System.out.println(num1);
        System.out.println(num2);
        System.out.println(num3);
        System.out.println(num4);

输出结果：
9
8517
-1589272251
2397499697075167557

7.数值可以加下划线用作分隔符

不过要注意下划线添加的一些标准，下划线不允许出现在开头和结尾。

8.简化了可变参数方法的调用

9.新增加了Objects类

它提供了一些方法来操作对象，这些方法大多数是“空指针”安全的，比如　Objects.toString(obj)；如果obj是null,，则输出是null。
否则如果你自己用obj.toString()，如果obj是null，则会抛出NullPointerException
10.调用泛型类的构造方法时，可以省去泛型参数，编译器会自动判断。

JDK1.8

概述

Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。 Oracle 公司于 2014 年 3 月 18 日发布 Java 8 ，它支持函数式编程，新的 JavaScript 引擎，新的日期 API，新的Stream API 等。

特性

1.Lambda 表达式

Lambda 允许把函数作为一个方法的参数（函数作为参数传递到方法中）。

2.方法引用

方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。

3.函数式接口

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
函数式接口可以被隐式转换为 lambda 表达式。
Lambda 表达式和方法引用（实际上也可认为是Lambda表达式）上。

4.默认方法

默认方法就是一个在接口里面有了一个实现的方法。

5.Stream API

新添加的Stream API（java.util.stream）把真正的函数式编程风格引入到Java中。

6.Date Time API

加强对日期与时间的处理。

7.Optional 类

Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
Optional 类已经成为 Java 8 类库的一部分，用来解决空指针异常。

8.Nashorn, JavaScript 引擎

Java 8提供了一个新的Nashorn javascript引擎，它允许我们在JVM上运行特定的javascript应用。

9.Base64

在Java 8中，Base64编码已经成为Java类库的标准。
Java 8 内置了 Base64 编码的编码器和解码器。
Base64工具类提供了一套静态方法获取下面三种BASE64编解码器：
基本：输出被映射到一组字符A-Za-z0-9+/，编码不添加任何行标，输出的解码仅支持A-Za-z0-9+/。
URL：输出映射到一组字符A-Za-z0-9+_，输出是URL和文件。
MIME：输出隐射到MIME友好格式。输出每行不超过76字符，并且使用’\r’并跟随’\n’作为分割。编码输出最后没有行分割。

Java 1.9

概述

Java 9 发布于 2017 年 9 月 22 日，带来了很多新特性，其中最主要的变化是已经实现的模块化系统。

新特性

1.模块系统：模块是一个包的容器，Java 9 最大的变化之一是引入了模块系统（Jigsaw 项目）。

2.REPL (JShell)：交互式编程环境。

3.HTTP 2 客户端：HTTP/2标准是HTTP协议的最新版本，新的 HTTPClient API 支持 WebSocket 和 HTTP2 流以及服务器推送特性。

4.改进的 Javadoc：Javadoc 现在支持在 API 文档中的进行搜索。另外，Javadoc 的输出现在符合兼容 HTML5 标准。

5.多版本兼容 JAR 包：多版本兼容 JAR 功能能让你创建仅在特定版本的 Java 环境中运行库程序时选择使用的 class 版本。

6.集合工厂方法：List，Set 和 Map 接口中，新的静态工厂方法可以创建这些集合的不可变实例。

7.私有接口方法：在接口中使用private私有方法。我们可以使用 private 访问修饰符在接口中编写私有方法。

8.进程 API: 改进的 API 来控制和管理操作系统进程。引进 java.lang.ProcessHandle 及其嵌套接口 Info 来让开发者逃离时常因为要获取一个本地进程的 PID 而不得不使用本地代码的窘境。

9.改进的 Stream API：改进的 Stream API 添加了一些便利的方法，使流处理更容易，并使用收集器编写复杂的查询。

10.改进 try-with-resources：如果你已经有一个资源是 final 或等效于 final 变量,您可以在 try-with-resources 语句中使用该变量，而无需在 try-with-resources 语句中声明一个新变量。

11.改进的弃用注解 @Deprecated：注解 @Deprecated 可以标记 Java API 状态，可以表示被标记的 API 将会被移除，或者已经破坏。

12.改进钻石操作符(Diamond Operator) ：匿名类可以使用钻石操作符(Diamond Operator)。

13.改进 Optional 类：java.util.Optional 添加了很多新的有用方法，Optional 可以直接转为 stream。

14.多分辨率图像 API：定义多分辨率图像API，开发者可以很容易的操作和展示不同分辨率的图像了。

15.改进的 CompletableFuture API ： CompletableFuture 类的异步机制可以在 ProcessHandle.onExit 方法退出时执行操作。

16.轻量级的 JSON API：内置了一个轻量级的JSON API

17.响应式流（Reactive Streams) API: Java 9中引入了新的响应式流 API 来支持 Java 9 中的响应式编程。

附图

怎么替换java版本_Java

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：java 解析sdp协议

下一篇：真实云服务器keepalived virtual_ipaddress 地址填什么

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯