jdk新特性

最新推荐文章于 2022-12-10 16:31:41 发布

xikuang1311

最新推荐文章于 2022-12-10 16:31:41 发布

阅读量349

点赞数

分类专栏： Java 文章标签： java jdk

本文链接：https://blog.csdn.net/qq_34792920/article/details/122058955

版权

Java 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

jdk新特性：

JDK1.5新特性：

1.自动装箱与拆箱：

自动装箱的过程：每当需要一种类型的对象时，这种基本类型就自动地封装到与它相同类型的包装中。

自动拆箱的过程：每当需要一个值时，被装箱对象中的值就被自动地提取出来，没必要再去调用intValue()和doubleValue()方法。

自动装箱，只需将该值赋给一个类型包装器引用，java会自动创建一个对象。

自动拆箱，只需将该对象值赋给一个基本类型即可。

java——类的包装器

类型包装器有：Double,Float,Long,Integer,Short,Character和Boolean

2.枚举

把集合里的对象元素一个一个提取出来。枚举类型使代码更具可读性，理解清晰，易于维护。枚举类型是强类型的，从而保证了系统安全性。而以类的静态字段实现的类似替代模型，不具有枚举的简单性和类型安全性。

简单的用法：JavaEnum简单的用法一般用于代表一组常用常量，可用来代表一类相同类型的常量值。

复杂用法：Java为枚举类型提供了一些内置的方法，同事枚举常量还可以有自己的方法。可以很方便的遍历枚举对象。

3.静态导入

通过使用 import static，就可以不用指定 Constants 类名而直接使用静态成员，包括静态方法。

import xxxx 和 import static xxxx的区别是前者一般导入的是类文件如import java.util.Scanner;后者一般是导入静态的方法，import static java.lang.System.out。

4.可变参数（Varargs）

可变参数的简单语法格式为：

methodName([argumentList], dataType…argumentName);

5.内省（Introspector）

是 Java语言对Bean类属性、事件的一种缺省处理方法。例如类A中有属性name,那我们可以通过getName,setName来得到其值或者设置新的值。通过getName/setName来访问name属性，这就是默认的规则。Java中提供了一套API用来访问某个属性的getter /setter方法，通过这些API可以使你不需要了解这个规则（但你最好还是要搞清楚），这些API存放于包java.beans中。

一般的做法是通过类Introspector来获取某个对象的BeanInfo信息，然后通过BeanInfo来获取属性的描述器（PropertyDescriptor），通过这个属性描述器就可以获取某个属性对应的getter/setter方法，然后我们就可以通过反射机制来调用这些方法。

6.泛型(Generic)

C++ 通过模板技术可以指定集合的元素类型，而Java在1.5之前一直没有相对应的功能。一个集合可以放任何类型的对象，相应地从集合里面拿对象的时候我们也不得不对他们进行强制得类型转换。猛虎引入了泛型，它允许指定集合里元素的类型，这样你可以得到强类型在编译时刻进行类型检查的好处。

7.For-Each循环

For-Each循环得加入简化了集合的遍历。假设我们要遍历一个集合对其中的元素进行一些处理。

JDK 1.6新特性

1.Desktop类和SystemTray类

在JDK6中 ,AWT新增加了两个类:Desktop和SystemTray。

前者可以用来打开系统默认浏览器浏览指定的URL,打开系统默认邮件客户端给指定的邮箱发邮件,用默认应用程序打开或编辑文件(比如,用记事本打开以txt为后缀名的文件),用系统默认的打印机打印文档;后者可以用来在系统托盘区创建一个托盘程序.

2.使用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文档。除了JAXB之外，我们还可以通过XMLBeans和Castor等来实现同样的功能。

3.理解StAX

StAX(JSR 173)是JDK6.0中除了DOM和SAX之外的又一种处理XML文档的API。

StAX 的来历：在JAXP1.3(JSR 206)有两种处理XML文档的方法:DOM(Document Object Model)和SAX(Simple API for XML).

由于JDK6.0中的JAXB2(JSR 222)和JAX-WS 2.0(JSR 224)都会用到StAX所以Sun决定把StAX加入到JAXP家族当中来，并将JAXP的版本升级到1.4(JAXP1.4是JAXP1.3的维护版本). JDK6里面JAXP的版本就是1.4. 。

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(JSR 199)去动态编译Java源文件，Compiler API结合反射功能就可以实现动态的产生Java代码并编译执行这些代码，有点动态语言的特征。

这个特性对于某些需要用到动态编译的应用程序相当有用，比如JSP Web Server，当我们手动修改JSP后，是不希望需要重启Web Server才可以看到效果的，这时候我们就可以用Compiler API来实现动态编译JSP文件，当然，现在的JSP Web Server也是支持JSP热部署的，现在的JSP Web Server通过在运行期间通过Runtime.exec或ProcessBuilder来调用javac来编译代码，这种方式需要我们产生另一个进程去做编译工作，不够优雅而且容易使代码依赖与特定的操作系统；Compiler API通过一套易用的标准的API提供了更加丰富的方式去做动态编译,而且是跨平台的。

5.轻量级Http Server API

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

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

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

实际上JSR 269不仅仅用来处理Annotation,我觉得更强大的功能是它建立了Java 语言本身的一个模型,它把method, package, constructor, type, variable, enum, annotation等Java语言元素映射为Types和Elements(两者有什么区别?), 从而将Java语言的语义映射成为对象, 我们可以在javax.lang.model包下面可以看到这些类. 所以我们可以利用JSR 269提供的API来构建一个功能丰富的元编程(metaprogramming)环境.

JSR 269用Annotation Processor在编译期间而不是运行期间处理Annotation, Annotation Processor相当于编译器的一个插件,所以称为插入式注解处理.如果Annotation Processor处理Annotation时(执行process方法)产生了新的Java代码,编译器会再调用一次Annotation Processor,如果第二次处理还有新代码产生,就会接着调用Annotation Processor,直到没有新代码产生为止.每执行一次process()方法被称为一个"round",这样整个Annotation processing过程可以看作是一个round的序列.

JSR 269主要被设计成为针对Tools或者容器的API. 举个例子,我们想建立一套基于Annotation的单元测试框架(如TestNG),在测试类里面用Annotation来标识测试期间需要执行的测试方法。

7.用Console开发控制台程序

JDK6 中提供了java.io.Console 类专用来访问基于字符的控制台设备. 你的程序如果要与Windows下的cmd或者Linux下的Terminal交互,就可以用Console类代劳. 但我们不总是能得到可用的Console, 一个JVM是否有可用的Console依赖于底层平台和JVM如何被调用. 如果JVM是在交互式命令行(比如Windows的cmd)中启动的,并且输入输出没有重定向到另外的地方,那么就可以得到一个可用的Console实例.

8.对脚本语言的支持如: ruby, groovy, javascript.

9.Common Annotations

Common annotations原本是Java EE 5.0(JSR 244)规范的一部分，现在SUN把它的一部分放到了Java SE 6.0中.

随着Annotation元数据功能(JSR 175)加入到Java SE 5.0里面，很多Java 技术(比如EJB,Web Services)都会用Annotation部分代替XML文件来配置运行参数（或者说是支持声明式编程,如EJB的声明式事务）, 如果这些技术为通用目的都单独定义了自己的Annotations,显然有点重复建设, 所以,为其他相关的Java技术定义一套公共的Annotation是有价值的，可以避免重复建设的同时，也保证Java SE和Java EE 各种技术的一致性.

下面列举出Common Annotations 1.0里面的10个Annotations Common Annotations

Annotation Retention Target Description

Generated Source ANNOTATION_TYPE, CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE 用于标注生成的源代码

Resource Runtime TYPE, METHOD, FIELD 用于标注所依赖的资源,容器据此注入外部资源依赖，有基于字段的注入和基于setter方法的注入两种方式

Resources Runtime TYPE 同时标注多个外部依赖，容器会把所有这些外部依赖注入

PostConstruct Runtime METHOD 标注当容器注入所有依赖之后运行的方法，用来进行依赖注入后的初始化工作，只有一个方法可以标注为PostConstruct

PreDestroy Runtime METHOD 当对象实例将要被从容器当中删掉之前，要执行的回调方法要标注为PreDestroy RunAs Runtime TYPE 用于标注用什么安全角色来执行被标注类的方法，这个安全角色必须和Container 的Security角色一致的。RolesAllowed Runtime TYPE, METHOD 用于标注允许执行被标注类或方法的安全角色，这个安全角色必须和Container 的Security角色一致的

PermitAll Runtime TYPE, METHOD 允许所有角色执行被标注的类或方法

DenyAll Runtime TYPE, METHOD 不允许任何角色执行被标注的类或方法，表明该类或方法不能在Java EE容器里面运行

DeclareRoles Runtime TYPE 用来定义可以被应用程序检验的安全角色，通常用isUserInRole来检验安全角色

注意:

1.RolesAllowed,PermitAll,DenyAll不能同时应用到一个类或方法上

2.标注在方法上的RolesAllowed,PermitAll,DenyAll会覆盖标注在类上的RolesAllowed,PermitAll,DenyAll

3.RunAs,RolesAllowed,PermitAll,DenyAll和DeclareRoles还没有加到Java SE 6.0上来

\4. 处理以上Annotations的工作是由Java EE容器来做, Java SE 6.0只是包含了上面表格的前五种Annotations的定义类,并没有包含处理这些Annotations的引擎,这个工作可以由Pluggable Annotation Processing API(JSR 269)来做

改动的地方最大的就是java GUI界面的显示了，JDK6.0（也就是JDK1.6）支持最新的windows vista系统的Windows Aero视窗效果，而JDK1.5不支持！！！

你要在vista环境下编程的话最好装jdk6.0，否则它总是换到windows basic视窗效果.

JDK 1.7 新特性

1，switch中可以使用字串了

2，"<>"这个玩意儿的运用List tempList = new ArrayList<>(); 即泛型实例化类型自动推断。

public class JDK7GenericTest {
   public static void main(String[] args) {
      // Pre-JDK 7
      List<String> lst1 = new ArrayList<String>();
      // JDK 7 supports limited type inference for generic instance creation
      List<String> lst2 = new ArrayList<>();
  
      lst1.add("Mon");
      lst1.add("Tue");
      lst2.add("Wed");
      lst2.add("Thu");
  
      for (String item: lst1) {
         System.out.println(item);
      }
  
      for (String item: lst2) {
         System.out.println(item);
      }
   }
}

3. 自定义自动关闭类

以下是jdk7 api中的接口，（不过注释太长，删掉了close()方法的一部分注释）

/**
 * A resource that must be closed when it is no longer needed.
 *
 * @author Josh Bloch
 * @since 1.7
 */
public interface AutoCloseable {
    /**
     * Closes this resource, relinquishing any underlying resources.
     * This method is invoked automatically on objects managed by the
     * {@code try}-with-resources statement.
     *
     */
    void close() throws Exception;
}

只要实现该接口，在该类对象销毁时自动调用close方法，你可以在close方法关闭你想关闭的资源，例子如下

class TryClose implements AutoCloseable {

 @Override
 public void close() throw Exception {
  System.out.println(" Custom close method …
                                         close resources ");
 }
}
//请看jdk自带类BufferedReader如何实现close方法（当然还有很多类似类型的类）

  public void close() throws IOException {
        synchronized (lock) {
            if (in == null)
                return;
            in.close();
            in = null;
            cb = null;
        }
    }

4. 新增一些取环境信息的工具方法

File System.getJavaIoTempDir() // IO临时文件夹

File System.getJavaHomeDir() // JRE的安装目录

File System.getUserHomeDir() // 当前用户目录

File System.getUserDir() // 启动java进程时所在的目录

.......

5. Boolean类型反转，空指针安全,参与位运算

Boolean Booleans.negate(Boolean booleanObj)

True => False , False => True, Null => Null

boolean Booleans.and(boolean[] array)

boolean Booleans.or(boolean[] array)

boolean Booleans.xor(boolean[] array)

boolean Booleans.and(Boolean[] array)

boolean Booleans.or(Boolean[] array)

boolean Booleans.xor(Boolean[] array)

6. 两个char间的equals

boolean Character.equalsIgnoreCase(char ch1, char ch2)

7，安全的加减乘除

int Math.safeToInt(long value)

int Math.safeNegate(int value)

long Math.safeSubtract(long value1, int value2)

long Math.safeSubtract(long value1, long value2)

int Math.safeMultiply(int value1, int value2)

long Math.safeMultiply(long value1, int value2)

long Math.safeMultiply(long value1, long value2)

long Math.safeNegate(long value)

int Math.safeAdd(int value1, int value2)

long Math.safeAdd(long value1, int value2)

long Math.safeAdd(long value1, long value2)

int Math.safeSubtract(int value1, int value2)

8.对Java集合（Collections）的增强支持

在JDK1.7之前的版本中，Java集合容器中存取元素的形式如下：

以List、Set、Map集合容器为例：

//创建List接口对象
    List<String> list=new ArrayList<String>();
    list.add("item"); //用add()方法获取对象
    String Item=list.get(0); //用get()方法获取对象

 

    //创建Set接口对象
    Set<String> set=new HashSet<String>();
    set.add("item"); //用add()方法添加对象

 

    //创建Map接口对象
    Map<String,Integer> map=new HashMap<String,Integer>();
    map.put("key",1); //用put()方法添加对象
    int value=map.get("key");

在JDK1.7中，摒弃了Java集合接口的实现类，如：ArrayList、HashSet和HashMap。而是直接采用[]、{}的形式存入对象，采用[]的形式按照索引、键值来获取集合中的对象，如下：

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集合中获取对象

9.数值可加下划线

10.支持二进制文字

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

当程序员试图使用一个不可具体化的可变参数并调用一个varargs （可变）方法时，编辑器会生成一个“非安全操作”的警告。

12、在try catch异常扑捉中，一个catch可以写多个异常类型，用"|"隔开，

jdk7之前：

try {
   ......
} catch(ClassNotFoundException ex) {
   ex.printStackTrace();
} catch(SQLException ex) {
   ex.printStackTrace();
}

jdk7例子如下

try {
   ......
} catch(ClassNotFoundException|SQLException ex) {
   ex.printStackTrace();
}

7、jdk7之前，你必须用try{}finally{}在try内使用资源，在finally中关闭资源，不管try中的代码是否正常退出或者异常退出。jdk7之后，你可以不必要写finally语句来关闭资源，只要你在try()的括号内部定义要使用的资源。请看例子：

JAVA8 十大新特性

本教程将Java8的新特新逐一列出，并将使用简单的代码示例来指导你如何使用默认接口方法，lambda表达式，方法引用以及多重Annotation，之后你将会学到最新的API上的改进，比如流，函数式接口，Map以及全新的日期API

“Java is still not dead—and people are starting to figure that out.”

本教程将用带注释的简单代码来描述新特性，你将看不到大片吓人的文字。

一、接口的默认方法
Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可，这个特征又叫做扩展方法，示例如下：

代码如下:

1、本地变量类型推断（Local Var）

在Lambda表达式中，可以使用var关键字来标识变量，变量类型由编译器自行推断。

// LocalVar.java
import java.util.Arrays;
public class LocalVar {
    public static void main(String[] args) {
        Arrays.asList("Java", "Python", "Ruby")
            .forEach((var s) -> {
                System.out.println("Hello, " + s);
            });
    }
}

局部变量类型推断就是左边的类型直接使用 var 定义，而不用写具体的类型，编译器能根据右边的表达式自动推断类型。

2、字符串加强

String新增了strip()方法，和trim()相比，strip()可以去掉Unicode空格，例如，中文空格：

// 判断字符串是否为空白
" ".isBlank(); // true
// 去除首尾空格
" Javastack ".strip(); // "Javastack"
// 去除尾部空格
" Javastack ".stripTrailing(); // " Javastack"
// 去除首部空格
" Javastack ".stripLeading(); // "Javastack "
// 复制字符串
"Java".repeat(3);// "JavaJavaJava"
// 行数统计
"A\nB\nC".lines().count(); 
// 3

3、集合加强

自 Java 9 开始，Jdk 里面为集合（List/ Set/ Map）都添加了 of 和 copyOf 方法，它们两个都用来创建不可变的集合，来看下它们的使用和区别。

示例1：

var list = List.of("Java", "Python", "C");
var copy = List.copyOf(list);
System.out.println(list == copy); // true

示例2：

var list = new ArrayList<String>();
var copy = List.copyOf(list);
System.out.println(list == copy); // false

示例1和2代码差不多，为什么一个为true,一个为false?

来看下它们的源码：

可以看出 copyOf 方法会先判断来源集合是不是 AbstractImmutableList 类型的，如果是，就直接返回，如果不是，则调用 of 创建一个新的集合。

示例2因为用的 new 创建的集合，不属于不可变 AbstractImmutableList 类的子类，所以 copyOf 方法又创建了一个新的实例，所以为false.

注意：使用of和copyOf创建的集合为不可变集合，不能进行添加、删除、替换、排序等操作，不然会报 java.lang.UnsupportedOperationException 异常。

上面演示了 List 的 of 和 copyOf 方法，Set 和 Map 接口都有。

4、Stream 加强

Stream 是 Java 8 中的新特性，Java 9 开始对 Stream 增加了以下 4 个新方法。

增加单个参数构造方法，可为null

Stream.ofNullable(null).count(); // 0

增加 takeWhile 和 dropWhile 方法

Stream.of(1, 2, 3, 2, 1)
.takeWhile(n -> n < 3)
.collect(Collectors.toList()); // [1, 2]

从开始计算，当 n < 3 时就截止。

Stream.of(1, 2, 3, 2, 1)
.dropWhile(n -> n < 3)
.collect(Collectors.toList()); // [3, 2, 1]

这个和上面的相反，一旦 n < 3 不成立就开始计算。

iterate重载

这个 iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代。

5、Optional 加强

Opthonal 也增加了几个非常酷的方法，现在可以很方便的将一个 Optional 转换成一个 Stream, 或者当一个空 Optional 时给它一个替代的。

Optional.of("javastack").orElseThrow(); // javastack
Optional.of("javastack").stream().count(); // 1
Optional.ofNullable(null)
.or(() -> Optional.of("javastack"))
.get(); // javastack

6、InputStream 加强

InputStream 终于有了一个非常有用的方法：transferTo，可以用来将数据直接传输到 OutputStream，这是在处理原始数据流时非常常见的一种用法，如下示例。

var classLoader = ClassLoader.getSystemClassLoader();
var inputStream = classLoader.getResourceAsStream("javastack.txt");
var javastack = File.createTempFile("javastack2", "txt");
try (var outputStream = new FileOutputStream(javastack)) {
    inputStream.transferTo(outputStream);
}

7、HTTP Client API

这是 Java 9 开始引入的一个处理 HTTP 请求的的孵化 HTTP Client API，该 API 支持同步和异步，而在 Java 11 中已经为正式可用状态，你可以在 java.net 包中找到这个 API。

来看一下 HTTP Client 的用法：

var request = HttpRequest.newBuilder()
.uri(URI.create("https://javastack.cn"))
.GET()
.build();
var client = HttpClient.newHttpClient();
// 同步
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
// 异步
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
.thenApply(HttpResponse::body)
.thenAccept(System.out::println);

上面的 .GET() 可以省略，默认请求方式为 Get！

8、读写文件

对Files类增加了writeString和readString两个静态方法，可以直接把String写入文件，或者把整个文件读出为一个String：

Files.writeString(
    Path.of("./", "tmp.txt"), // 路径
    "hello, jdk11 files api", // 内容
    StandardCharsets.UTF_8); // 编码
String s = Files.readString(
    Paths.get("./tmp.txt"), // 路径
    StandardCharsets.UTF_8); // 编码

这两个方法可以大大简化读取配置文件之类的问题。

9、单文件代码

这个功能允许你直接使用java解析器运行java代码。java文件会在内存中执行编译并且直接执行。唯一的约束在于所有相关的类必须定义在一个java文件中。
最基础的案例
把以下代码保存到Hello.java文件中：

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("Hello World!!!");
    }
}

我们将会按照下面的方法来执行上面的代码：

PS G:\samples\java11\single-file> java HelloWorld.java
Hello World!!!

在上面的例子，我们仅仅只是在一个类中包含了一个main方法。我们直接使用java命令去执行这个.java文件。如果这个文件不是以.java结尾，我们可以使用—source参数来执行.
包含命令行参数
接下来的案例，我们传入一个参数

public class Greeting{
    public static void main(String[] args){
        if ( args == null || args.length < 1 ){
            System.err.println("Name required");
            System.exit(1);
        }
        System.out.println(String.format("Hello %s!!", args[0]));
    }
}

我们把上面的代码保存到HelloGreeting.java文件中。注意，这个文件名字和类的名字不匹配。我们按照如下命令执行：

PS G:\samples\java11\single-file> java HelloGreeting.Java sana
Hello sana!!

任何一个跟在文件名后面的参数都被作为方法的参数传入方法执行。
我们把HelloGreeting.java直接重新命名为greeting（注意，没有.java后缀），我们再次执行：

PS G:\samples\java11\single-file> java greeting sana
Error: Could not find or load main class greeting
Caused by: java.lang.ClassNotFoundException: greeting

可以看到，在没有.java结尾的情况下，java编译器会尝试直接使用传入的名称作为类名去寻找.class文件。在这种情况下，我们需要使用—source选项：

PS G:\samples\java11\single-file> java --source 11 greeting sana
Hello sana!!

一个文件中包含多个类
文章开头我就提到，这个特性只是要求所有需要执行的代码是在同一个java文件中即可，而没有规定在这个java文件中只能有一个类。我们下面就来看看在一个java文件中包含多个类的情况：

public class SimpleInterest{
    public static void main(String[] args){
        if ( args == null || args.length < 3 ){
            System.err.println("Three arguments required: principal, rate, period");
            System.exit(1);
        }
        int principal = Integer.parseInt(args[0]);
        int rate = Integer.parseInt(args[1]);
        int period = Integer.parseInt(args[2]);
        double interest = Maths.simpleInterest(principal, rate, period);
        System.out.print("Simple Interest is: " + interest);
    }
}
 
public class Maths{
 
    public static double simpleInterest(int principal, int rate, int period){
        return ( principal * rate * period * 1.0 ) / 100;
    }
}

我们来运行这个代码：

PS G:\samples\java11\single-file> java .\SimpleInterest.java 1000 2 10
Simple Interest is: 200.0

在这个文件中，我们定义了多个类，但是在执行的时候，java编译器会运行这个文件中第一个类中的main方法（注：意思是，这个文件中的第一个类需要包含main方法，并且这个main方法作为运行的方法）

Shebang文件
在本小节中，我们会创建一个shebang文件。Shebang文件是Unix系统中常见的文件，以#!/path/to/executable作为文件的开头第一行，可以作为脚本小程序直接运行一段代码。

我们来创建一个shebang文件：

#!/g/jdk-11/bin/java --source 11
 
public class SimpleInterest{
    public static void main(String[] args){
        if ( args == null || args.length < 3 ){
            System.err.println("Three arguments required: principal, rate, period");
            System.exit(1);
        }
        int principal = Integer.parseInt(args[0]);
        int rate = Integer.parseInt(args[1]);
        int period = Integer.parseInt(args[2]);
        double interest = Maths.simpleInterest(principal, rate, period);
        System.out.print("Simple Interest is: " + interest);
    }
}
 
public class Maths{
 
    public static double simpleInterest(int principal, int rate, int period){
        if ( rate > 100 ){
            System.err.println("Rate of interest should be <= 100. But given values is " + rate);
            System.exit(1);
        }
        return ( principal * rate * period * 1.0 ) / 100;
    }
}

当文件的名字不符合java命名规范的时候，就可以创建shebang文件来执行。比如我们上面的代码就可以保存在一个叫simpleInterest的文件中。我们需要按照下面的方式来运行：

sanaulla@Sana-Laptop  /g/samples/java11/single-file (master)
$ ./simpleInterest 1000 20 2
Simple Interest is: 400.0

在windows下，我们只能使用bash shell来执行。当然，还有诸如Cygwin，Windows 10 Ubuntu Support等工具来执行。

jdk1.9新特性

你可能已经听说过 Java 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 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 类。

Java 10的新特性

说了这么多，看Java 10都会有哪些特性来改变我们写代码的方式呢？！

1.局部变量类型推断

局部变量类型推断可以说是Java 10中最值得注意的特性，这是Java语言开发人员为了简化Java应用程序的编写而采取的又一步，如下图所示。

这个新功能将为Java增加一些语法糖 - 简化它并改善开发者体验。新的语法将减少与编写Java相关的冗长度，同时保持对静态类型安全性的承诺。

局部变量类型推断将引入"var"关键字，也就是你可以随意定义变量而不必指定变量的类型，如：

1. `List <String> list = new ArrayList <String>（）;`
2. `Stream <String> stream = getStream（）;`

将被下面这个新语法所取代：

1. `var list = new ArrayList <String>（）;`
2. `var stream = getStream（）;`

看完是不是有点JS的即视感？？？越来越像JS了吗？！虽然类型推断在Java中不是一个新概念，但在局部变量中确是很大的一个改进。

说到类型推断，从JDK 5引进泛型，到JDK 7的"<>"操作符允许不绑定类型而初始化List，再到JDK 8的Lambda表达式，再到现在JDK 10的局部变量类型推断，Java类型推断正大刀阔斧的向前发展。

1. `// 该运算符允许在没有绑定ArrayList <>的类型的情况下初始化列表`
2. `List <String> list = new LinkedList <>（）;

局部变量类型推荐仅限于如下使用场景：

局部变量初始化
for循环内部索引变量
传统的for循环声明变量

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工具，这个很简单并且很重要。

JDK11新增Http客户端

官方文档： http://openjdk.java.net/jeps/321

这个功能在JDK 9中引入并在JDK 10中得到了更新，最终JDK11正式发布，支持 HTT/1.1, HTTP/2

常用类和接口

HttpClient.Builder
HttpClient 构建工具类

HttpRequest.Builder
HttpRequest 构建工具类

HttpRequest.BodyPublisher
将java 对象转换为可发送的HTTP request body字节流, 如form表单提交

HttpResponse.BodyHandler
处理理接收到的 Response Body

创建HttpClient, 下面结果是一致的底层调用

//var httpClient = HttpClient.newBuilder().build();
var httpClient = HttpClient.newHttpClient();

创建get请求

//private static final String targetUrl =
"http://api.vincent.net/pub/api/v1/web/all_category";
private static final URI uri = URI.create(targetUrl);
//GET请求
private static void testGet() {
    //var httpClient = HttpClient.newHttpClient();
    //设置建立连接超时 connect timeout
    var httpClient =
        HttpClient.newBuilder().connectTimeout(Duration.ofMillis(5000)).build();
    //设置读取数据超时 read timeout
    var request =
        HttpRequest.newBuilder().timeout(Duration.ofMillis(3000))
        .header("key1", "v1")
        .header("key2", "v2")
        .uri(uri).build();
    try {
        var response = httpClient.send(request,
            HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

JDK11新增Http客户端提交post请求和异步请求

使用HttpClient提交Post请求


private static final String targetUrl
    = "https://api.vincent.net/pub/api/v1/web/web_login";
private static final URI uri = URI.create(targetUrl);
//POST请求
private static void testPost() {
        var httpClient = HttpClient.newHttpClient();
        var request = HttpRequest.newBuilder()
            .uri(uri)
        //json格式则使用下面数据
        //.header("Content-Type", "application/json")
        //.POST(HttpRequest.BodyPublishers.ofString("
        {
            \
            "phone\":\"13113777337\",\"pwd\":\"1234567890\"}"))
    //form表单则使用下面配置
    .header("Content-Type", "application/x-www-form-
        urlencoded ")
        .POST(HttpRequest.BodyPublishers.ofString("phone=13113777337&pwd=1234567
                890 "))
                .build();
                try {
                    var response = httpClient.send(request,
                        HttpResponse.BodyHandlers.ofString());
                    System.out.println(response.body());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

使用HttpClient提交异步GET请求

//异步GET请求
//private static final String targetUrl =
"http://api.vincent.net/pub/api/v1/web/all_category";
private static final URI uri = URI.create(targetUrl);
//异步请求通过CompletableFuture实现。
private static void testAsynGet() {
    var httpClient = HttpClient.newBuilder().build();
    var request =
        HttpRequest.newBuilder().timeout(Duration.ofMillis(3000))
        .header("key1", "v1")
        .header("key2", "v2")
        .uri(uri).build();
    try {
        //CompletableFuture<String> result = httpClient.sendAsync(request,
        //HttpResponse.BodyHandlers.ofString()).thenApply(HttpResponse::body);
    var result = httpClient.sendAsync(request,HttpResponse.BodyHandlers.ofString())
        .thenApply(HttpResponse::body);
    System.out.println(result.get());
} catch (Exception e) {
    e.printStackTrace();
}
}

JDK11新增Http客户端提交http2请求
HTTP2 百科
HTTP/2 （原名HTTP/2.0）即超文本传输协议 2.0，是下一代HTTP协议。是由互联网工程任务组（IETF）的Hypertext Transfer Protocol Bis (httpbis)工作小组进行开发。是自1999年http1.1发布后的首个更新。HTTP 2.0在2013年8月进行首次合作共事性测试。在开放互联网上HTTP 2.0将只用于https://网址，而 http://网址将继续使用HTTP/1，目的是在开放互联网上增加使用加密技术，以提供强有力的保护去遏制主动攻击。DANE RFC6698允许域名管理员不通过第三方CA自行发行证书

HTTP2协议的强制要求https，如果目标URI是HTTP的，则无法使⽤用HTTP 2协议
如何判断网站是否是http2协议，浏览器器，network面板，选择protocol

private static final String targetUrl = "https://http2.akamai.com/demo";
private static final URI uri = URI.create(targetUrl);
private static void testHttp2() {
    var httpClient = HttpClient.newBuilder()
        .connectTimeout(Duration.ofMillis(3000))
        .version(HttpClient.Version.HTTP_2)
        .build();
    var request = HttpRequest.newBuilder()
        .timeout(Duration.ofMillis(3000))
        .header("key1", "v1")
        .header("key2", "v2")
        .uri(uri)
        .build();
    try {
        var response = httpClient.send(request,HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
        System.out.println(response.version());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

java编译运行命令在jdk11中的改善

jdk11前运行java程序
jdk11后运行java程序(本地不会生成class文件)

JDK12新特性：

1、Switch Expressions

这是一个为开发者准备的特性，我们可以利用具体代码快速了解一下，下面是传统 statement 形式的 switch 语法：

switch (day) {
case MONDAY:
case FRIDAY:
case SUNDAY:
System.out.println(6);
break;
case TUESDAY:
System.out.println(7);
break;
case THURSDAY:
case SATURDAY:
System.out.println(8);
break;
case WEDNESDAY:
System.out.println(9);
break;
}

如果有编码经验，你一定知道，switch 语句如果漏写了一个 break，那么逻辑往往就跑偏了，这种方式既繁琐，又容易出错。如果换成 switch 表达式，Pattern Matching 机制能够自然地保证只有单一路径会被执行，请看下面的代码示例：

switch (day) {
case MONDAY, FRIDAY, SUNDAY -> System.out.println(6);
case TUESDAY -> System.out.println(7);
case THURSDAY, SATURDAY -> System.out.println(8);
case WEDNESDAY -> System.out.println(9);
}

更进一步，下面的表达式，为我们提供了优雅地表达特定场合计算逻辑的方式

int numLetters = switch (day) {
case MONDAY, FRIDAY, SUNDAY -> 6;
case TUESDAY -> 7;
case THURSDAY, SATURDAY -> 8;
case WEDNESDAY -> 9;
};

Switch Expressions 或者说起相关的 Pattern Matching 特性，为我们提供了勾勒出了 Java 语法进化的一个趋势，将开发者从复杂繁琐的低层次抽象中逐渐解放出来，以更高层次更优雅的抽象，既降低代码量，又避免意外编程错误的出现，进而提高代码质量和开发效率。

2、Shenandoah GC

新增了一个名为 Shenandoah 的 GC 算法，通过与正在运行的 Java 线程同时进行 evacuation 工作来减少 GC 暂停时间。使用 Shenandoah 的暂停时间与堆大小无关，这意味着无论堆是 200 MB 还是 200 GB，都将具有相同的暂停时间。

…

jdk13新特性

1、switch优化更新

jdk11以及之前的版本：

switch (day) {
    case MONDAY:
    case FRIDAY:
    case SUNDAY:
         System.out.println(6);
         break;
    case TUESDAY:
        System.out.println(7);
        break; case THURSDAY:
    case SATURDAY:
        System.out.println(8);
         break;
    case WEDNESDAY:
         System.out.println(9);
         break;

jdk12版本：

switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> System.out.println(6);
    case TUESDAY -> System.out.println(7);
    case THURSDAY, SATURDAY -> System.out.println(8);
    case WEDNESDAY -> System.out.println(9);
}

jdk13版本：

static void howMany(int k) {
    System.out.println(
        switch (k) {
            case  1 -> "one"
            case  2 -> "two"
            default -> "many"
        }
    );

}

2、文本块升级

jdk13之前：

String html = "<html>\n" +
              "    <body>\n" +
              "        <p>Hello, world</p>\n" +
              "    </body>\n" +
              "</html>\n";

jdk13优化后：

String html = """
              <html>
                  <body>
                      <p>Hello, world</p>
                  </body>
              </html>

上面这一串相当于字符串文字：

"line 1\nline 2\nline 3\n"

3、重新实现旧版套接字API

使用更简单、更现代的实现替换java.net.Socket和java.net.ServerSocket API使用的底层实现，易于维护和调试。新的实现很容易适应用户模式线程，也就是光纤。之前的底层实现可以追溯到jdk1.0，实现是遗留java和c代码的混合，维护和调试很痛苦，该实现使用线程堆栈作为I/O缓冲区，这种方式需要多次增加默认线程堆栈大小。

4、核心库/java.util中：I18N

支持Unicode12.1，此版本将Unicode支持升级到12.1，其中包括以下内容：

java.lang.Character支持12.1级的Unicode字符数据库，其中12.0从11.0开始增加554个字符，总共137,928个字符。
这些新增内容包括4个新脚本，总共150个脚本，以及61个新的表情符号字符。U+32FF SQUARE ERA NAME REIWA
从 12.0开始，12.1只添加一个字符。java.text.Bidi和java.text.Normalizer类分别支持12.0级的Unicode标准附件，＃9和＃15。java.util.regexpackage支持基于12.0级Unicode标准附件＃29的扩展字形集群。
5、取消使用未使用的内存

增加ZGC以将未使用的堆内存返回给操作系统。ZGC目前没有取消提交并将内存返回给操作系统，即使该内存长时间未使用。对于所有类型的应用程序和环境，此行为并非最佳，尤其是那些需要关注内存占用的应用程序和环境例如：通过使用支付资源的容器环境。应用程序可能长时间处于空闲状态并与许多其他应用程序共享或竞争资源的环境。应用程序在执行期间可能具有非常不同的堆空间要求。

例如，启动期间所需的堆可能大于稳态执行期间稍后所需的堆。HotSpot中的其他垃圾收集器，如G1和Shenandoah，今天提供了这种功能，某些类别的用户发现它非常有用。将此功能添加到ZGC将受到同一组用户的欢迎。

jdk14新特性

部分名词解释：

预览版：该功能在当前版本可以使用，如果效果不是很好的话，可能以后的其他版本就会删去该功能。
最终版：该功能在之前版本效果很好，之后的每个版本中都会存在该功能。

1、switch优化变更为最终版

与之前的jdk12、13功能一样，只是从之前的预览版变为最终版

2、垃圾回收相关

1）删除cms垃圾收集器

2）弃用 ParallelScavenge + SerialOld GC 的垃圾回收算法组合

3）将 zgc 垃圾回收器移植到 macOS 和 windows 平台

3、instanceof的模式匹配（预览版）

instanceof运算符支持模式匹配来增强java语言，如下：

if (obj instanceof String s) {
// can use s here
} else {
// can’t use s here
}

4、删除了安全库java.security.acl API

5、货币格式（优化）

可以通过 NumberFormat.getCurrencyInstance(Locale)使用“ u-cf-account” Unicode区域设置扩展名来获得具有记帐样式的
货币格式实例，其中金额在某些区域设置中用括号表示，例如，Locale.US,它将格式化为($3.27)而不是-$3.27。

xikuang1311

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
jdk新特性

jdk新特性：JDK1.5新特性：1.自动装箱与拆箱：自动装箱的过程：每当需要一种类型的对象时，这种基本类型就自动地封装到与它相同类型的包装中。自动拆箱的过程：每当需要一个值时，被装箱对象中的值就被自动地提取出来，没必要再去调用intValue()和doubleValue()方法。自动装箱，只需将该值赋给一个类型包装器引用，java会自动创建一个对象。自动拆箱，只需将该对象值赋给一个基本类型即可。java——类的包装器类型包装器有：Double,Float,Long,Integer,Shor
复制链接

扫一扫

专栏目录