作者:因情语写
链接:https://www.proprogrammar.com/article/740
声明:请尊重原作者的劳动,如需转载请注明出处
经过4次跳票,历经曲折的java 9 终于终于在2017年9月21日发布。
java 9 提供了超过150项新功能特性,包括备受期待的模块化系统、可交互的 REPL 工具:jshell,JDK 编译工具,Java 公共 API 和私有代码,以及安全增强、扩展提升、性能管理改善等。可以说Java 9是一个庞大的系统工程,完全做了一个整体改变。
具体来讲:
Java 更快的发布周期意味着开发者将不需要像以前一样为主要发布版本望眼欲穿。这也意味着开发者将可能跳过 Java 9 和它的不成熟的模块化功能,只需要再等待 6 个月就可以迎来新版本,这将可能解决开发者的纠结。
oracle 理念 与 小步快跑,快速迭代
http://www.oracle.com/technetwork/java/javase/downloads/index-jsp-138363.html
下载安装完毕,需要配置环境变量:
① 新建JAVA_HOME的环境变量,变量值为jdk路径。如下:
② 将JAVA_HOME 配置到path环境变量下:
之后在命令行校验是否配置成功。成功,则显示如下:
http://www.oracle.com/technetwork/java/javase/documentation/jdk9-doc-downloads-3850606.html
https://docs.oracle.com/javase/9/
官方提供的新特性列表:
https://docs.oracle.com/javase/9/whatsnew/toc.htm#JSNEW-GUID-C23AFD78-C777-460B-8ACE-58BE5EA681F6
或参考 Open JDK
http://openjdk.java.net/projects/jdk9/
Features JEP 102: Process API Updates JEP 110: HTTP 2 Client JEP 143: Improve Contended Locking JEP 158: Unified JVM Logging JEP 165: Compiler Control JEP 193: Variable Handles JEP 197: Segmented Code Cache JEP 199: Smart Java Compilation, Phase Two JEP 200: The Modular JDK JEP 201: Modular Source Code JEP 211: Elide Deprecation Warnings on Import Statements JEP 212: Resolve Lint and Doclint Warnings JEP 213: Milling Project Coin JEP 214: Remove GC Combinations Deprecated in JDK 8 JEP 215: Tiered Attribution for javac JEP 216: Process Import Statements Correctly JEP 217: Annotations Pipeline 2.0 JEP 219: Datagram Transport Layer Security (DTLS) JEP 220: Modular Run-Time Images JEP 221: Simplified Doclet API JEP 222: jshell: The Java Shell (Read-Eval-Print Loop) JEP 223: New Version-String Scheme JEP 224: HTML5 Javadoc JEP 225: Javadoc Search JEP 226: UTF-8 Property Files JEP 227: Unicode 7.0 |
特性 102:API 更新过程 110:2 HTTP 客户端 143:改善竞争锁 158:统一 JVM 日志记录 165:编译器控制 193:变量处理 197:分段代码缓存 199:聪明的 Java 编译,第二阶段 200:模块化 JDK 201:模块化的源代码 211: 导入语句时省略警告信息 212:解决 Lint 和 Doclint 警告 213:研磨项目 Coin 214:移除 JDK 8 过时的 GC 组合 215:javac 分层归因 216:正确处理导入语句 217:2.0 注释管道 219:数据报传输层安全性(DTLS) 220:模块化运行时图像 221:简化 Doclet API 222:jshell:Java Shell(Read-Eval-Print-Loop) 223: 字符串新版本方案 224:Javadoc 支持 HTML5 225:Javadoc 搜索 226:utf - 8 属性文件 227:Unicode 7.0 |
JEP 228: Add More Diagnostic Commands JEP 229: Create PKCS12 Keystores by Default JEP 231: Remove Launch-Time JRE Version Selection JEP 232: Improve Secure Application Performance JEP 233: Generate Run-Time Compiler Tests Automatically JEP 235: Test Class-File Attributes Generated by javac JEP 236: Parser API for Nashorn JEP 237: Linux/AArch64 Port JEP 238: Multi-Release JAR Files JEP 240: Remove the JVM TI hprof Agent JEP 241: Remove the jhat Tool JEP 243: Java-Level JVM Compiler Interface JEP 244: TLS Application-Layer Protocol Negotiation Extension JEP 245: Validate JVM Command-Line Flag Arguments JEP 246: Leverage CPU Instructions for GHASH and RSA JEP 247: Compile for Older Platform Versions JEP 248: Make G1 the Default Garbage Collector JEP 249: OCSP Stapling for TLS JEP 250: Store Interned Strings in CDS Archives JEP 251: Multi-Resolution Images JEP 252: Use CLDR Locale Data by Default JEP 253: Prepare JavaFX UI Controls & CSS APIs for Modularization JEP 254: Compact Strings JEP 255: Merge Selected Xerces 2.11.0 Updates into JAXP JEP 256: BeanInfo Annotations JEP 257: Update JavaFX/Media to Newer Version of GStreamer JEP 258: HarfBuzz Font-Layout Engine JEP 259: Stack-Walking API |
228:添加更多的诊断命令 229:创建 PKCS12 默认密钥存储库 231:删除启动 JRE 版本选择 232:提高安全应用程序性能 233:自动生成运行时编译器测试 235:测试 javac 生成的类文件属性 236:Nashorn 解析器 API 237:Linux / AArch64 端口 238:Multi-Release JAR 文件 240:删除 JVM TI hprof 代理 241:删除 jhat 工具 243:java 级别 JVM 编译器接口 244:TLS 应用层协议谈判扩展 245:JVM 命令行标记参数进行验证 246:利用 CPU 指令 GHASH 和 RSA 247:老平台版本编译 248:设置 G1 为默认的垃圾收集器 249:OCSP 装订 TLS 250:CDS 档案中存储实际字符串 251:多分辨率图像 252:使用系统默认语言环境数据 253 年:准备 JavaFX UI 控件和 CSS api 用于模块化 254:紧凑的字符串 255:合并选定的 Xerces 2.11.0 更新到 JAXP 256:BeanInfo 注释 257:更新 JavaFX /Media 到 GStreamer 的新版本 258:HarfBuzz 文字编排引擎 259:提供 Stack – Walking API |
JEP 260: Encapsulate Most Internal APIs JEP 261: Module System JEP 262: TIFF Image I/O JEP 263: HiDPI Graphics on Windows and Linux JEP 264: Platform Logging API and Service JEP 265: Marlin Graphics Renderer JEP 266: More Concurrency Updates JEP 267: Unicode 8.0 JEP 268: XML Catalogs JEP 269: Convenience Factory Methods for Collections JEP 270: Reserved Stack Areas for Critical Sections JEP 271: Unified GC Logging JEP 272: Platform-Specific Desktop Features JEP 273: DRBG-Based SecureRandom Implementations JEP 274: Enhanced Method Handles JEP 275: Modular Java Application Packaging JEP 276: Dynamic Linking of Language-Defined Object Models JEP 277: Enhanced Deprecation JEP 278: Additional Tests for Humongous Objects in G1 JEP 279: Improve Test-Failure Troubleshooting JEP 280: Indify String Concatenation JEP 281: HotSpot C++ Unit-Test Framework JEP 282: jlink: The Java Linker JEP 283: Enable GTK 3 on Linux JEP 284: New HotSpot Build System JEP 285: Spin-Wait Hints JEP 287: SHA-3 Hash Algorithms JEP 288: Disable SHA-1 Certificates |
260:封装内部 api 261:模块系统 262:TIFF 图像 I/O 263:Windows 和 Linux 上的 HiDPI 图形 264:日志 API 和服务平台 265:Marlin 图形渲染器 266:更多的并发更新 267:Unicode 8.0 268:XML 目录 269:方便的集合工厂方法 270:保留堆栈领域至关重要的部分 271:统一的 GC 日志记录 272:特定于平台的桌面功能 273:基于 DRBG 的 SecureRandom 实现 274:增强的方法处理 275:模块化 Java 应用程序包装 276:语言定义对象模型的动态链接 277:增强的弃用 278:为 G1 的极大对象提供额外的测试 279:改善测试失败的故障排除 280:Indify 字符串连接 281:热点 c++的单元测试框架 282:jlink:Java 连接器 283:在 Linux 上启用 GTK 3 284:新热点的构建系统 285:循环等待提示 287:SHA-3 散列算法 288:禁用 sha - 1 证书 |
JEP 289: Deprecate the Applet API JEP 290: Filter Incoming Serialization Data 291: Deprecate the Concurrent Mark Sweep (CMS) Garbage Collector JEP 292: Implement Selected ECMAScript 6 Features in Nashorn JEP 294: Linux/s390x Port JEP 295: Ahead-of-Time Compilation JEP 297: Unified arm32/arm64 Port JEP 298: Remove Demos and Samples JEP 299: Reorganize Documentation |
289:标记过时的 Applet API 290:过滤传入的序列化数据 291:反对并发标记清理垃圾收集器(CMS) 292:实现选定的 ECMAScript Nashorn 6 特性 294:Linux / s390x 端口 295:提前编译 297:统一的 arm32 / arm64 端口 298:删除演示和样本 299:整理文档 |
小组:对特定技术内容,比如安全、网络、 HotSpot 等有共同兴趣的组织和个人
项目:编写代码、文档以及其他工作,至少由一个小组赞助和支持,比如最近的 Lambda 计划, JigSaw 计划等
JDK : Java Development Kit (Java 开发工具包)
JRE : Java Runtime Environment (Java 运行环境)
说明:
JDK = JRE + 开发工具集(例如 Javac 编译工具等)
JRE = JVM + Java SE 标准类库
说明:
bin 目录 | 包含命令行开发和调试工具,如 javac, jar 和 javadoc。 |
include 目录 | 包含在编译本地代码时使用的 C/C++头文件 |
lib 目录 | 包含 JDK 工具的几个 JAR 和其他类型的文件。 它有 一个 tools.jar 文件,其中包含 javac 编译器的 Java 类 |
jre/bin 目录 | 包含基本命令,如 java 命令。 在 Windows 平台上, 它包含系统的运行时动态链接库(DLL)。 |
jre/lib 目录 | 包含用户可编辑的配置文件,如.properties 和.policy 文件。包含几个 JAR。 rt.jar 文件包含运行时的 Java 类和资源文件。 |
说明:
没有名为 jre 的子目录 | |
bin 目录 | 包含所有命令。 在 Windows 平台上,它继续包含系 统的运行时动态链接库。 |
conf 目录 | 包含用户可编辑的配置文件,例如以前位于 jre\lib 目 录中的.properties 和.policy 文件 |
include 目录 | 包含要在以前编译本地代码时使用的 C/C++头文件。 它只存在于 JDK 中 |
jmods 目录 | 包含 JMOD 格式的平台模块。 创建自定义运行时映像 时需要它。 它只存在于 JDK 中 |
legal 目录 | 包含法律声明 |
lib 目录 | 包含非 Windows 平台上的动态链接本地库。 其子目 录和文件不应由开发人员直接编辑或使用 |
200: The Modular JDK
201: Modular Source Code
220: Modular Run-Time Images
260: Encapsulate Most Internal APIs
261: Module System
282: jlink: The Java Linker
Java 运行环境的膨胀和臃肿。 每次JVM启动的时候, 至少会有30~60MB的内存加载,主要原因是JVM需要加载rt.jar,不管其中的类是否被classloader加载,第一步整个jar都会被JVM加载到内存当中去(而模块化可以根据模块的需要加载程序运行需要的class)
当代码库越来越大,创建复杂, 盘根错节的“意大利面条式代码” 的几率呈指数级的增长。 不同版本的类库交叉依赖导致让人头疼的问题, 这些都阻碍了 Java 开发和运行效率的提升。
很难真正地对代码进行封装, 而系统并没有对不同部分(也就是 JAR 文件)之间的依赖关系有个明确的概念。 每一个公共类都可以被类路径之下任何其它的公共类所访问到, 这样就会导致无意中使用了并不想被公开访问的 API。
类路径本身也存在问题: 你怎么知晓所有需要的 JAR 都已经有了, 或者是不是会有重复的项呢?
模块独立、 化繁为简
模块化(以 Java 平台模块系统的形式) 将 JDK 分成一组模块, 可以在编译时, 运行时或者构建时进行组合。
注: IntelliJ IDEA 2017.3 支持模块化特性,这里选择此开发环境。
模块将由通常的类和新的模块声明文件(module-info.java)组成。该文件是位于 java 代码结构的顶层,该模块描述符明确地定义了我们的模块需要什么依赖关系,以及哪些模块被外部使用。在 exports 子句中未提及的所有包默认情况下将封装在模块中,不能在外部使用。
java 9demo 模块中的 ModuleTest 类使用如下:
package com.atguigu.java;Java 9 -宋红康
import com.atguigu.bean.Person;
import org.junit.Test;
import java.util.logging.Logger;
/**
* Created by songhongkang on 2017/12/27 0027.
*/
public class ModuleTest {
private static final Logger LOGGER =
Logger.getLogger("java9test");
public static void main(String[] args) {
Person p = new Person("马云",40);
System.out.println(p);
LOGGER.info("aaaaaa");
}
@Test
public void test1(){
System.out.println("hello");
}
}
对应在 java 9demo 模块的 src 下创建 module-info.java 文件:
/**
* Created by songhongkang on 2017/12/27 0027.
*/
module java9demo {
requires java9test;
requires java.logging;
requires junit;
}
requires:指明对其它模块的依赖。
在 java9test 模块的指定包下提供类 Person:
package com.atguigu.bean;
/**
* Created by songhongkang on 2017/12/27 0027.
*/
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
} p
ublic String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
要想在 java9demo 模块中调用 java9test 模块下包中的结构,需要在java9test 的 module-info.java 中声明:
/**
* Created by songhongkang on 2017/12/27 0027.
*/
module java9test {
//package we export
exports com.atguigu.bean;
}
exports:控制着哪些包可以被其它模块访问到。所有不被导出的包默认都被封装在模块里面。
关于更多 Java 9 模块编程的内容请参考一本书:《Java 9 Modularity》里面讲的比较详细,介绍了当前 Java 对 jar 之间以来的管理是多么的混乱,引入 modularity 之后的改变会是很明显的差别。
222: jshell: The Java Shell (Read-Eval-Print Loop)
像 Python 和 Scala 之类的语言早就有交互式编程环境 REPL (read -evaluate - print - loop)了, 以交互式的方式对语句和表达式进行求值。开发者只需要输入一些代码,就可以在编译前获得对程序的反馈。而之前的 Java 版本要想执行代码,必须创建文件、 声明类、 提供测试方法方可实现。
即写即得、快速运行
调出 jShell
获取帮助
基本使用
Tips:在 JShell 环境下,语句末尾的“;” 是可选的。但推荐还是最好加上。提高代码可读性。
导入指定的包
默认已经导入如下的所有包:(包含java.lang包)
只需按下 Tab 键,就能自动补全代码
列出当前 session 里所有有效的代码片段
查看当前 session 下所有创建过的变量
查看当前 session 下所有创建过的方法
Tips:我们还可以重新定义相同方法名和参数列表的方法,即为对现有方法的修改(或覆盖)。
使用外部代码编辑器来编写 Java 代码
从外部文件加载源代码
指定目录下提供HelloWorld.java文件:
/**
* Created by songhongkang on 2017/12/27 0020.
*/
public void printHello() {
System.out.println("马上 2018 年了,尚硅谷祝所有的谷粉元旦
快乐! ");
}
printHello();
使用/open 命令调用:
没有受检异常(编译时异常)
说明:本来应该强迫我们捕获一个IOException,但却没有出现。因为jShell在后台为我们隐藏了。
退出jShell
238: Multi-Release JAR Files
当一个新版本的Java出现的时候,你的库用户要花费数年时间才会切换到这个新的版本。这就意味着库得去向后兼容你想要支持的最老的Java版本(许多情况下就是Java 6 或者 Java7)。这实际上意味着未来的很长一段时间,你都不能在库中运用Java 9所提供的新特性。幸运的是,多版本兼容jar功能能让你创建仅在特定版本的Java环境中运行库程序选择使用的class版本。
举例1:
jar root
- A.class
- B.class
- C.class
- D.class
- META-INF
- versions
- 9
- A.class
- B.class
说明:
在上述场景中, root.jar 可以在 Java 9 中使用, 不过 A或B 类使用的不是顶层的 root.A或root.B 这两个class, 而是处在“META-INF/versions/9”下面的这两个。这是特别为 Java 9 准备的 class 版本,可以运用 Java 9 所提供的特性和库。同时,在早期的 Java 诸版本中使用这个 JAR 也是能运行的,因为较老版本的 Java 只会看到顶层的A类或 B 类。
举例2:
jar root
- A.class
- B.class
- C.class
- D.class
- META-INF
- versions
- 9
- A.class
- B.class
- 10
- A.class
官方说明:
By this scheme, it is possible for versions of a class designed for a later Java platform release to override the version of that same class designed for an earlier Java platform release.
步骤一:提供必要的类
在指定目录(E:\teach\01_Java9\multijar\src\main\java\com\atguigu)下提供如下的类:
【Generator.java】
package com.atguigu;
import java.util.Set;
import java.util.HashSet;
/**
* Created by songhongkang on 2017/12/28 0028.
*/
public class Generator {
public Set<String> createStrings() {
Set<String> strings = new HashSet<String>();
strings.add("Java");
strings.add("8");
return strings;
}
}
【Application.java】
package com.atguigu;
import com.atguigu.Generator;
import java.io.IOException;
import java.util.List;
import java.util.ArrayList;
import java.util.Set;
/**
* Created by songhongkang on 2017/12/28 0028.
*/
public class Application {
public static void testMultiJar() {
com.atguigu.Generator gen = new Generator();
System.out.println("Generated strings: " +
gen.createStrings());
}
}
在如下目录(E:\teach\01_Java9\multijar\src\main\java-9\com\atguigu)下提供同名的类:
【Generator.java】
package com.atguigu;
import java.util.Set;
/**
* Created by songhongkang on 2017/12/28 0028.
*/
public class Generator {
public Set<String> createStrings() {
return Set.of("Java", "9");
}
}
步骤二:打包
指令如下:
javac -d build --release 8 src/main/java/com/atguigu/*.java |
javac -d build9 --release 9 src/main/java-9/com/atguigu/*.java |
jar --create --main-class=Application --file multijar.jar -C build . --release 9 -C build9 . |
步骤三:在java 9 及之前版本的环境下进行测试即可
213: Milling Project Coin
Support for private methods in interfaces was briefly in consideration for inclusion in Java SE 8 as part of the effort to add support for Lambda Expressions, but was withdrawn to enable better focus on higher priority tasks for Java SE 8. It is now proposed that support for private interface methods be undertaken thereby enabling non abstract methods of an interface to share code between them.
Java 8中规定接口中的方法除了抽象方法之外,还可以定义静态方法和默认的方法。一定程度上,扩展了接口的功能,此时的接口更像是一个抽象类。
在Java 9中,接口更加的灵活和强大,连方法的访问权限修饰符都可以声明为private的了,此时方法将不会成为你对外暴露的API的一部分。
/**
* Created by songhongkang
*/
interface MyInterface {
void normalInterfaceMethod();
default void methodDefault1() {
init();
}
public default void methodDefault2() {
init();
}
// This method is not part of the public API exposed by
MyInterface
private void init() {
System.out.println("默认方法中的通用操作");
}
}
class MyInterfaceImpl implements MyInterface{
@Override
public void normalInterfaceMethod() {
System.out.println("实现接口的方法");
}
}
public class MyInterfaceTest{
public static void main(String[] args) {
MyInterfaceImpl impl = new MyInterfaceImpl();
impl.methodDefault1();
// impl.init();//不能调用
}
}
private List<String> flattenStrings(List<String>... lists) {
Set<String> set = new HashSet<>(){};
for(List<String> list : lists) {
set.addAll(list);
}
return new ArrayList<>(set);
}
编译报错信息: '<>' cannot be used with anonymous classes
private List<String> flattenStrings(List<String>... lists) {
// anonymous classes can now use type inference
Set<String> set = new HashSet<>(){};
for(List<String> list : lists) {
set.addAll(list);
}
return new ArrayList<>(set);
}
在 java 8 之前,我们习惯于这样处理资源的关闭:
InputStreamReader reader = null;
try{
reader = new InputStreamReader(System.in);
//流的操作
reader.read();
}catch (IOException e){
e.printStackTrace();
}finally{
if(reader != null){
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
java 8 中, 可以实现资源的自动关闭,但是要求执行后必须关闭的所有资源必须在 try 子句中初始化, 否则编译不通过。 如下例所示:
try(InputStreamReader reader = new
InputStreamReader(System.in)){
}catch (IOException e){
e.printStackTrace();
}
java 9 中, 用资源语句编写 try 将更容易,我们可以在 try 子句中使用已经初始化过的资源,此时的资源是 final 的:
InputStreamReader reader = new InputStreamReader(System.in);
OutputStreamWriter writer = new OutputStreamWriter(System.out);
try(reader;writer){
//reader 是 final 的,不可再被赋值
// reader = null;
}catch (IOException e){
e.printStackTrace();
}
在 java 8 中,标识符可以独立使用“_”来命名:
String _ = "hello";
System.out.println(_);
但是,在 java 9 中规定“_”不再可以单独命名标识符了,如果使用,会报错:
JEP 254: Compact Strings
Motivation
The current implementation of the String class stores characters in a char array, using two bytes (sixteen bits) for each character. Data gathered from many different applications indicates that strings are a major component of heap usage and, moreover, that most String objects contain only Latin-1 characters. Such characters require only one byte of storage, hence half of the space in the internal char arrays of such String objects is going unused.
Description
We propose to change the internal representation of the String class from a UTF-16 char array to a byte array plus an encoding-flag field. The new String class will store characters encoded either as ISO-8859-1/Latin-1 (one byte per character), or as UTF-16 (two bytes per character), based upon the contents of the string. The encoding flag will indicate which encoding is used.
结论:String 再也不用 char[] 来存储啦,改成了 byte[] 加上编码标记,节约了一些空间。
public final class String
implements java.io.Serializable, Comparable<String>,
CharSequence {
@Stable
private final byte[] value;
那 StringBuffer 和 StringBuilder 是否仍无动于衷呢?
String-related classes such as AbstractStringBuilder, StringBuilder, and StringBuffer will be updated to use the same representation, as will the HotSpot VM's intrinsic string operations.
269: Convenience Factory Methods for Collections
要创建一个只读、 不可改变的集合,必须构造和分配它,然后添加元素,最后包装成一个不可修改的集合。
比如:
List<String> namesList = new ArrayList <>();
namesList.add("Joe");
namesList.add("Bob");
namesList.add("Bill");
namesList = Collections.unmodifiableList(namesList);
System.out.println(namesList);
缺点:我们一下写了五行。即:它不能表达为单个表达式。
当然,我们也可以稍微简单点处理:
List<String> list =
Collections.unmodifiableList(Arrays.asList("a", "b", "c"));
Set<String> set = Collections.unmodifiableSet(new
HashSet<>(Arrays.asList("a", "b", "c")));
//如下操作不适用于 jdk 8 及之前版本,适用于 jdk 9
Map<String,Integer> map = Collections.unmodifiableMap(new
HashMap<>(){
{
put("a", 1);
put("b", 2);
put("c", 3);
}
});
map.forEach((k,v) -> System.out.println(k + ":" + v));
Java 9 因此引入了方便的方法,这使得类似的事情更容易表达。
List firsnamesList = List.of(“Joe”,”Bob”,”Bill”);
调用集合中静态方法 of(),可以将不同数量的参数传输到此工厂方法中。此功能可用于 Set 和 List,也可用于 Map 的类似形式。 此时得到的集合,是不可变的: 在创建后,继续添加元素到这些集合会导致“UnsupportedOperationException” 。
由于 Java 8 中接口方法的实现,可以直接在 List, Set 和 Map 的接口内定义这些方法,便于调用。
List<String> list = List.of("a", "b", "c");
Set<String> set = Set.of("a", "b", "c");
Map<String, Integer> map1 = Map.of("Tom", 12, "Jerry", 21,
"Lilei", 33, "HanMeimei", 18);
Map<String, Integer> map2 = Map.ofEntries(
Map.entry("Tom", 89),
Map.entry("Jim", 78),
Map.entry("Tim", 98)
);
Java 的 Steam API 是java标准库最好的改进之一, 让开发者能够快速运算, 从而能够有效的利用数据并行计算。 Java 8 提供的 Steam能够利用多核架构实现声明式的数据处理。
在 Java 9 中, Stream API 变得更好, Stream 接口中添加了 4 个新的方法: dropWhile, takeWhile, ofNullable, 还有个 iterate 方法的新重载方法,可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代。 (见下例)
除了对 Stream 本身的扩展, Optional 和 Stream 之间的结合也得到了改进。现在可以通过 Optional 的新方法 stream() 将一个Optional 对象转换为一个(可能是空的) Stream 对象。 (见下例)
takeWhile()的使用:
用于从 Stream 中获取一部分数据,接收一个 Predicate 来进行选择。在有序的Stream 中, takeWhile 返回从开头开始的尽量多的元素。
List<Integer> list =
Arrays.asList(45,43,76,87,42,77,90,73,67,88);
list.stream().takeWhile(x -> x < 50)
.forEach(System.out::println);
System.out.println();
list = Arrays.asList(1,2,3,4,5,6,7,8);
list.stream().takeWhile(x -> x < 5)
.forEach(System.out::println);
dropWhile()的使用:
dropWhile 的行为与 takeWhile 相反,返回剩余的元素。
List<Integer> list =
Arrays.asList(45,43,76,87,42,77,90,73,67,88);
list.stream().dropWhile(x -> x < 50)
.forEach(System.out::println);
System.out.println();
list = Arrays.asList(1,2,3,4,5,6,7,8);
list.stream().dropWhile(x -> x < 5)
.forEach(System.out::println);
ofNullable()的使用:
Java 8 中 Stream 不能完全为 null,否则会报空指针异常。 而 Java 9 中的ofNullable 方法允许我们创建一个单元素 Stream,可以包含一个非空元素,也可以创建一个空 Stream。
//报 NullPointerException
//Stream<Object> stream1 = Stream.of(null);
//System.out.println(stream1.count());
//不报异常,允许通过
Stream<String> stringStream = Stream.of("AA", "BB", null);
System.out.println(stringStream.count());//3
//不报异常,允许通过
List<String> list = new ArrayList<>();
list.add("AA");
list.add(null);
System.out.println(list.stream().count());//2
//ofNullable():允许值为 null
Stream<Object> stream1 = Stream.ofNullable(null);
System.out.println(stream1.count());//0
Stream<String> stream = Stream.ofNullable("hello world");
System.out.println(stream.count());//1
iterator()重载的使用:
原来的控制终止方式:
Stream.iterate(1,i -> i + 1).limit(10)
.forEach(System.out::println);
现在的终止方式:
Stream.iterate(1,i -> i < 100,i -> i + 1)
.forEach(System.out::println);
Optional 类中 stream()的使用:
List<String> list = new ArrayList<>();
list.add("Tom");
list.add("Jerry");
list.add("Tim");
Optional<List<String>> optional =
Optional.ofNullable(list);
Stream<List<String>> stream = optional.stream();
stream.flatMap(x ->
x.stream()).forEach(System.out::println);
251: Multi-Resolution Images
263: HiDPI Graphics on Windows and Linux
在 Mac 上,JDK 已经支持视网膜显示,但在 Linux 和 Windows 上,它并没有。在那里, Java 程序在当前的高分辨率屏幕上可能看起来很小,不能使用它们。这是因为像素用于这些系统的大小计算(无论像素实际有多大)。毕竟,高分辨率显示器的有效部分是像素非常小。
JEP 263 以这样的方式扩展了 JDK,即 Windows 和 Linux 也考虑到像素的大小。为此,使用比现在更多的现代 API: Direct2D for Windows和 GTK +, 而不是 Xlib for Linux。图形,窗口和文本由此自动缩放。
JEP 251 还提供处理多分辨率图像的能力,即包含不同分辨率的相同图像的文件。根据相应屏幕的 DPI 度量,然后以适当的分辨率使用图像。
110: HTTP 2 Client
HTTP,用于传输网页的协议,早在 1997 年就被采用在目前的 1.1版本中。直到 2015 年, HTTP2 才成为标准。
HTTP/1.1和HTTP/2的主要区别是如何在客户端和服务器之间构建和传输数据。HTTP/1.1依赖于请求/响应周期。 HTTP/2允许服务器“push”数据:它可以发送比客户端请求更多的数据。 这使得它可以优先处理并发送对于首先加载网页至关重要的数据。
Java 9中有新的方式来处理HTTP调用。它提供了一个新的HTTP客户端(HttpClient),它将替代仅适用于blocking模式的HttpURLConnection (HttpURLConnection是在HTTP 1.0的时代创建的,并使用了协议无关的方法),并提供对WebSocket 和 HTTP/2的支持。
此外,HTTP客户端还提供API来处理HTTP/2的特性,比如流和服务器推送等功能。
全新的HTTP客户端API可以从jdk.incubator.httpclient模块中获取。因为在默认情况下,这个模块是不能根据classpath获取的,需要使用add modules命令选项配置这个模块,将这个模块添加到classpath中。
举例:
HttpClient client = HttpClient.newHttpClient();
HttpRequest req =
HttpRequest.newBuilder(URI.create("http://www.atguigu.com"
))
.GET()
.build();
HttpResponse<String> response = client.send(req,
HttpResponse.BodyHandler.asString());
System.out.println(response.statusCode());
System.out.println(response.version().name());
System.out.println(response.body());
211: Elide Deprecation Warnings on Import Statements
214: Remove GC Combinations Deprecated in JDK 8
277: Enhanced Deprecation
289: Deprecate the Applet API
291: Deprecate the Concurrent Mark Sweep (CMS) Garbage Collector
Java 9 废弃或者移除了几个不常用的功能。其中最主要的是 Applet API,现在是标记为废弃的。随着对安全要求的提高,主流浏览器已经取消对 Java 浏览器插件的支持。HTML5 的出现也进一步加速了它的消亡。开发者现在可以使用像 Java Web Start 这样的技术来代替 Applet,它可以实现从浏览器启动应用程序或者安装应用程序。
同时,appletviewer 工具也被标记为废弃。
139: Enhance javac to Improve Build Speed.
199: Smart Java Compilation, Phase Two
智能java编译工具( sjavac )的第一个阶段始于JEP139这个项目,用于在多核处理器情况下提升JDK的编译速度。如今,这个项目已经进入第二阶段,即JEP199,其目的是改进Java编译工具,并取代目前JDK编译工具javac,继而成为Java环境默认的通用的智能编译工具。
JDK 9 还更新了javac 编译器以便能够将 java 9 代码编译运行在低版本 Java 中。
158: Unified JVM Logging
271: Unified GC Logging
日志是解决问题的唯一有效途径:曾经很难知道导致JVM性能问题和导致JVM崩溃的根本原因。不同的JVM日志的碎片化和日志选项(例如:JVM组件对于日志使用的是不同的机制和规则),这使得JVM难以进行调试。
解决该问题最佳方法:对所有的JVM组件引入一个单一的系统,这些JVM组件支持细粒度的和易配置的JVM日志。
224: HTML5 Javadoc
225: Javadoc Search
jdk 8 :生成的java帮助文档是在HTML 4 中,而HTML 4 已经是很久的标准了。
jdk 9 :javadoc的输出,现在符合兼容HTML 5 标准。
下图是java8 中生成的html页面,如果想要找到一些类文档,必须在google中搜索。
下图是在java 9 中,添加了一个搜索框。
236: Parser API for Nashorn
292: Implement Selected ECMAScript 6 Features in Nashorn
Nashorn 项目在 JDK 9 中得到改进,它为 Java 提供轻量级的 Javascript 运行时。Nashorn 项目跟随 Netscape 的 Rhino 项目,目的是为了在 Java 中实现一个高性能但轻量级的 Javascript 运行时。Nashorn 项目使得 Java 应用能够嵌入 Javascript。它在 JDK 8 中为 Java 提供一个 Javascript 引擎。
JDK 9 包含一个用来解析 Nashorn 的 ECMAScript 语法树的 API。这个 API 使得 IDE 和服务端框架不需要依赖 Nashorn 项目的内部实现类,就能够分析 ECMAScript 代码。
243: Java-Level JVM Compiler Interface
295: Ahead-of-Time Compilation
Oracle 一直在努力提高 Java 启动和运行时性能,希望其能够在更广泛的场景达到或接近本地语言的性能。但是,直到今天,谈到 Java,很多 C/C++ 开发者还是会不屑地评价为启动慢,吃内存。
简单说,这主要是因为 Java 编译产生的类文件是 Java 虚拟机可以理解的二进制代码,而不是真正的可执行的本地代码,需要 Java 虚拟机进行解释和编译,这带来了额外的开销。
JIT(Just-in-time)编译器可以在运行时将热点编译成本地代码,速度很快。但是 Java 项目现在变得很大很复杂,因此 JIT 编译器需要花费较长时间才能热身完,而且有些 Java 方法还没法编译,性能方面也会下降。AoT 编译就是为了解决这些问题而生的。
在 JDK 9 中, AOT(JEP 295: Ahead-of-Time Compilation)作为实验特性被引入进来,开发者可以利用新的 jaotc 工具将重点代码转换成类似类库一样的文件。虽然仍处于试验阶段,但这个功能使得 Java 应用在被虚拟机启动之前能够先将 Java 类编译为原生代码。此功能旨在改进小型和大型应用程序的启动时间,同时对峰值性能的影响很小。
但是 Java 技术供应商 Excelsior 的营销总监 Dmitry Leskov 担心 AoT 编译技术不够成熟,希望 Oracle 能够等到 Java 10 时有个更稳定版本才发布。
另外 JVMCI (JEP 243: Java-Level JVM Compiler Interface)等特性,对于整个编程语言的发展,可能都具有非常重要的意义,虽然未必引起了广泛关注。目前 Graal Core API 已经被集成进入 Java 9,虽然还只是初始一小步,但是完全用 Java 语言来实现的可靠的、高性能的动态编译器,似乎不再是遥不可及,这是 Java 虚拟机开发工程师的福音。
与此同时,随着 Truffle 框架和 Substrate VM 的发展,已经让个别信心满满的工程师高呼“One VM to Rule Them All!”, 也许就在不远的将来 Ploygot 以一种另类的方式成为现实。
一个标准化和轻量级的JSON API被许多java开发人员所青睐。但是由于资金问题无法在Java 9中见到,但并不会削减掉。Java平台首席架构师Mark Reinhold在JDK 9邮件列中说:“这个JEP将是平台上的一个有用的补充,但是在计划中,它并不像Oracle资助的其他功能那么重要,可能会重新考虑JDK 10或更高版本中实现。 ”
对许多应用而言货币价值都是一个关键的特性,但JDK对此却几乎没有任何支持。严格来讲,现有的java.util.Currency类只是代表了当前ISO 4217货币的一个数据结构,但并没有关联的值或者自定义货币。JDK对货币的运算及转换也没有内建的支持,更别说有一个能够代表货币值的标准类型了。
此前,Oracle 公布的JSR 354定义了一套新的Java货币API:JavaMoney,计划会在Java 9中正式引入。但是目前没有出现在JDK 9 中。
不过,如果你用的是Maven的话,可以做如下的添加,即可使用相关的API处理货币:
<dependency>
<groupId>org.javamoney</groupId>
<artifactId>moneta</artifactId>
<version>0.9</version>
</dependency>
代码参考,可以访问https://github.com/JavaMoney,里面已经给出了使用说明和示例。
亲爱的读者:有时间可以点赞评论一下
全部评论