Java是如何实现跨平台的？
目录
跨平台是怎样实现的呢？这就要谈及Java虚拟机（Java Virtual Machine，简称 JVM）。
JVM也是一个软件，不同的平台有不同的版本。我们编写的Java源码，编译后会生成一种 .class 文件，称为字节码文件。Java虚拟机就是负责将字节码文件翻译成特定平台下的机器码然后运行。也就是说，只要在不同平台上安装对应的JVM，就可以运行字节码文件，运行我们编写的Java程序。
而这个过程中，我们编写的Java程序没有做任何改变，仅仅是通过JVM这一”中间层“，就能在不同平台上运行，真正实现了”一次编译，到处运行“的目的。
JVM是一个”桥梁“，是一个”中间件“，是实现跨平台的关键，Java代码首先被编译成字节码文件，再由JVM将字节码文件翻译成机器语言，从而达到运行Java程序的目的。
注意：编译的结果不是生成机器码，而是生成字节码，字节码不能直接运行，必须通过JVM翻译成机器码才能运行。不同平台下编译生成的字节码是一样的，但是由JVM翻译成的机器码却不一样。
所以，运行Java程序必须有JVM的支持，因为编译的结果不是机器码，必须要经过JVM的再次翻译才能执行。即使你将Java程序打包成可执行文件（例如 .exe），仍然需要JVM的支持。
注意：跨平台的是Java程序，不是JVM。JVM是用C/C++开发的，是编译后的机器码，不能跨平台，不同平台下需要安装不同版本的JVM。
各个版本特性：
JAVA SE7
-
整数类型可以用二进制数系统表示；
-
数值字面量可以包含下划线字符以获得更好的可读性；
-
可以在switch语句中使用字符串；
-
在泛型实例的创建语法中引入了钻石运算符；
-
添加了新的带资源的try语句，多种异常类型可以包含在一个catch块中；
-
添加了一个新的编译器选项及两个注解，为改变可变参数方法中传递非具体化参数时的编译警告与错误；
-
引入了NIO.2 API可以为管理文件系统对象而开发自定义的文件系统供应程序；
-
API中的新增功能为文件I/O与文件系统访问提供了广泛的支持；
-
JDBC4.1 API可以使用带资源的try语句来自动关闭类型为Connection、Resultset、Statement的资源；
-
RowSet添加了一些功能，可以创建JDBC驱动支持的所有行集类型；
-
添加了对Solaris中流控制传输协议（SCTP）以及套接字连线协议（SDP）的支持；
-
JVM新增了一套叫做invokedynamic的指令为为支持动态类型化程序语言的实现；
-
并发API新增了轻量级的分支/合并（Fork/Join）框架；
-
Swing增加了下一代的跨平台外观，名为Nimbus外观等。
1，switch中可以使用字串了
String s = "test";
switch (s) {
case "test" :
System.out.println("test");
case "test1" :
System.out.println("test1");
break ;
default :
System.out.println("break");
break ;
}
2，"<>"这个玩意儿的运用List<String> tempList = new ArrayList<>(); 即泛型实例化类型自动推断。
mport java.util.*;
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)
对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集合中获取对象
3.数值可加下划线例如：int one_million = 1_000_000;
4.支持二进制文字
例如：int binary = 0b1001_1001;
5.简化了可变参数方法的调用
当程序员试图使用一个不可具体化的可变参数并调用一个*varargs* （可变）方法时，编辑器会生成一个“非安全操作”的警告。
6、在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()的括号内部定义要使用的资源。
前提是try()内的那些资源要实现自定义自动关闭类，这是新特性
try-with-resources statement。
请看例子：
jdk7之前
import java.io.*;
// Copy from one file to another file character by character.
// Pre-JDK 7 requires you to close the resources using a finally block.
public class FileCopyPreJDK7 {
public static void main(String[] args) {
BufferedReader in = null;
BufferedWriter out = null;
try {
in = new BufferedReader(new FileReader("in.txt"));
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();
} finally { // always close the streams
try {
if (in != null) in.close();
if (out != null) out.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
try {
in.read(); // Trigger IOException: Stream closed
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
jdk7之后
import java.io.*;
// Copy from one file to another file character by character.
// JDK 7 has a try-with-resources statement, which ensures that
// each resource opened in try() is closed at the end of the statement.
public class FileCopyJDK7 {
public static void main(String[] args) {
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();
}
}
}
JAVA7新增加了Objects类
它提供了一些方法来操作对象，这些方法大多数是“空指针”安全的，比如 Objects.toString(obj)；如果obj是null,，则输出是null。
否则如果你自己用obj.toString()，如果obj是null，则会抛出NullPointerException.
Java 7 更新[編輯]
Oracle直到2015年4月產品已經達到支援生命週期[129]快結束時才發佈JAVA 7家族每季的公開更新。[130]
| 版本 | 釋出日期 | 重點 |
|---|---|---|
| Java SE 7[131] | 2011-07-28 | 初始版本；HotSpot VM 21 |
| Java SE 7 Update 1[132] | 2011-10-18 | 20個安全漏洞修補；其它漏洞修補 |
| Java SE 7 Update 2[133] | 2011-12-12 | 沒有安全漏洞修補；HotSpot VM 22；可靠性和效能改進；支援 Solaris 11 和 Firefox 5 雨之後的版本；JavaFX 包含 Java SE JDK, 改善了網頁部屬的應用程式。 |
| Java SE 7 Update 3[134] | 2012-02-14 | 14個安全漏洞修補[135] |
| Java SE 7 Update 4[136] | 2012-04-26 | 沒有安全漏洞修補；HotSpot VM 23; JDK 支援 Mac OS X |
| Java SE 7 Update 5[137] | 2012-06-12 | 14個安全漏洞修補[138] |
| Java SE 7 Update 6[139] | 2012-08-14 | JavaFX 和 Java Access Bridge 被包含在 Java SE JDK 和 JRE 安裝裏面, JavaFX 支援輕觸熒幕和觸控板, JavaFX 支援 Linux, JDK 和 JRE 支援 Mac OS X, JDK 在 ARM 上支援 Linux [140] |
| Java SE 7 Update 7[141] | 2012-08-30 | 4個安全漏洞修補[142] |
| Java SE 7 Update 9[143] | 2012-10-16 | 30個安全漏洞修補[144] |
| Java SE 7 Update 10[145] | 2012-12-11 | 新的安全性功能，像是禁用任何Java應用程式在瀏覽器中運行的能力，以及當JRE處於不安全狀況時發出警告的新對話框，另外也有一些漏洞修復 |
| Java SE 7 Update 11[146] | 2013-01-13 | Olson Data 2012i；修復了在安裝了JavaFX的獨立版本的系統上外掛模組註冊問題, CVE-2013-0422 的安全修復；[147] Java applet和Web啟動應用程式的預設安全級別已從「中」增加到「高」 |
| Java SE 7 Update 13[148] | 2013-02-01 | 50個安全漏洞修補 |
| Java SE 7 Update 15[149] | 2013-02-19 | 5個安全漏洞修補 |
| Java SE 7 Update 17[150] | 2013-03-04 | 2個安全漏洞修補 |
| Java SE 7 Update 21[151] | 2013-04-16 | 許多的改變，包括 42 個安全漏洞修補, 新的不包含外掛模組的伺服器JRE , 以及以 ARM 架構運行的Linux上的 JDK |
| Java SE 7 Update 25[152] | 2013-06-18 | 許多的改變，包括 40 個安全漏洞修補[153] |
| Java SE 7 Update 40[154] | 2013-09-10 | 621個漏洞修補；[155] 新的安全性功能, hardfloat ARM, Java 任務控制（Java Mission Control） 5.2和Retina Display支援[156] |
| Java SE 7 Update 45[157] | 2013-10-15 | 51個安全漏洞修補；[158] 防止Java應用程式在未經授權時的重新分發；恢復安全提示；JAXP變化；TimeZone.setDefault的更改 |
| Java SE 7 Update 51[159] | 2014-01-14 | 36 個安全漏洞修補； 封鎖沒有表明身份的JAVA小程式（如遠程控制台－Java Applet－IBM IMM卡、HP iLO卡），即使警告對話框中有「將在下一版本中被封鎖」，[160][161] 17 個漏洞修補 |
| Java SE 7 Update 55[162] | 2014-04-15 | |
| Java SE 7 Update 60[165] | 2014-05-28 | |
| Java SE 7 Update 65[168] | 2014-07-15 | 18個漏洞修補[169] |
| Java SE 7 Update 67[170] | 2014-08-04 | 1個漏洞修補[171] |
| Java SE 7 Update 71[172] | 2014-10-14 | 16個漏洞修補[173] |
| Java SE 7 Update 72[174] | 2014-10-14 | 與Update 71相同的釋出日期，作為Java SE 7的相對應補丁集更新（Patch Set Update，PSU）；[175] 36 個漏洞修補[176] |
| Java SE 7 Update 75[177] | 2015-01-20 | 12個漏洞修補；[178] SSLv3預設為禁用 |
| Java SE 7 Update 76[179] | 2015-01-20 | 與Update 75相同的釋出日期，作為Java SE 7的相對應補丁集更新（Patch Set Update，PSU）； 97個漏洞修補[180] |
| Java SE 7 Update 79[181] | 2015-04-14 | 21個安全漏洞修補；6個漏洞修補[182] |
| Java SE 7 Update 80[183] | 2015-04-14 | Java 7的最後一個公開版本；與Update 79相同的發佈日期，作為Java SE 7的相對應補丁集更新（Patch Set Update，PSU）；104個漏洞修補[184] |
| Java SE 7 Update 85 | 2015-07-15 | 不公開，只能透過Java SE支援計劃和Solaris 10的Recommended Patchset Cluster 提供；25個安全漏洞修補 |
| Java SE 7 Update 91 | 2015-10-20 | 不公開，只能透過Java SE支援計劃和Solaris 10的Recommended Patchset Cluster 提供；20個安全漏洞修補 |
| Java SE 7 Update 95 | 2016-01-19 | 不公開，只能透過Java SE支援計劃和Solaris 10的Recommended Patchset Cluster 提供；8個安全漏洞修補[185] |
| Java SE 7 Update 97 | 2016-02-05 | 不公開，只能透過Java SE支援計劃和Solaris 10的Recommended Patchset Cluster 提供；1個安全漏洞修補[186] |
| Java SE 7 Update 99 | 2016-03-23 | 不公開，只能透過Java SE支援計劃和Solaris 10的Recommended Patchset Cluster 提供；1個安全漏洞修補[187] |
| Java SE 7 Update 101 | 2016-04-18 | 不公開，只能透過Java SE支援計劃和Solaris 10的Recommended Patchset Cluster 提供；9個安全漏洞修補 |
| Java SE 7 Update 111 | 2016-07-19 | 不公開，只能透過Java SE支援計劃和Solaris 10的Recommended Patchset Cluster 提供；36個安全漏洞修補 |
| Java SE 7 Update 121 | 2016-10-18 | 不公開，只能透過Java SE支援計劃和Solaris 10的Recommended Patchset Cluster 提供；32個安全漏洞修補 |
JAVA SE8
语言 编译器 库 工具 运行时（JVM）
2. Java语言的新特性
Java 8是Java的一个重大版本，有人认为，虽然这些新特性领Java开发人员十分期待，但同时也需要花不少精力去学习。在这一小节中，我们将介绍Java 8的大部分新特性。
2.1 Lambda表达式和函数式接口
Lambda表达式（也称为闭包）是Java 8中最大和最令人期待的语言改变。它允许我们将函数当成参数传递给某个方法，或者把代码本身当作数据处理：函数式开发者非常熟悉这些概念。很多JVM平台上的语言（Groovy、Scala等）从诞生之日就支持Lambda表达式，但是Java开发者没有选择，只能使用匿名内部类代替Lambda表达式。
Lambda的设计耗费了很多时间和很大的社区力量，最终找到一种折中的实现方案，可以实现简洁而紧凑的语言结构。最简单的Lambda表达式可由逗号分隔的参数列表、->符号和语句块组成，例如：
Arrays.asList( "a", "b", "d" ).forEach( e -> System.out.println( e ) );
在上面这个代码中的参数e的类型是由编译器推理得出的，你也可以显式指定该参数的类型，例如：
Arrays.asList( "a", "b", "d" ).forEach( ( String e ) -> System.out.println( e ) );
如果Lambda表达式需要更复杂的语句块，则可以使用花括号将该语句块括起来，类似于Java中的函数体，例如：
Arrays.asList( "a", "b", "d" ).forEach( e -> {
System.out.print( e );
System.out.print( e );
} );
Lambda表达式可以引用类成员和局部变量（会将这些变量隐式得转换成final的），例如下列两个代码块的效果完全相同：
String separator = ",";
Arrays.asList( "a", "b", "d" ).forEach(
( String e ) -> System.out.print( e + separator ) );
和
final String separator = ",";
Arrays.asList( "a", "b", "d" ).forEach(
( String e ) -> System.out.print( e + separator ) );
Lambda表达式有返回值，返回值的类型也由编译器推理得出。如果Lambda表达式中的语句块只有一行，则可以不用使用return语句，下列两个代码片段效果相同：
Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> e1.compareTo( e2 ) );
和
Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> {
int result = e1.compareTo( e2 );
return result;
} );
Lambda的设计者们为了让现有的功能与Lambda表达式良好兼容，考虑了很多方法，于是产生了函数接口这个概念。函数接口指的是只有一个函数的接口，这样的接口可以隐式转换为Lambda表达式。java.lang.Runnable和java.util.concurrent.Callable是函数式接口的最佳例子。在实践中，函数式接口非常脆弱：只要某个开发者在该接口中添加一个函数，则该接口就不再是函数式接口进而导致编译失败。为了克服这种代码层面的脆弱性，并显式说明某个接口是函数式接口，Java 8 提供了一个特殊的注解@FunctionalInterface（Java 库中的所有相关接口都已经带有这个注解了），举个简单的函数式接口的定义：
@FunctionalInterface
public interface Functional {
void method();
}
不过有一点需要注意，默认方法和静态方法不会破坏函数式接口的定义，因此如下的代码是合法的。
@FunctionalInterface
public interface FunctionalDefaultMethods {
void method();
default void defaultMethod() {
}
}
Lambda表达式作为Java 8的最大卖点，它有潜力吸引更多的开发者加入到JVM平台，并在纯Java编程中使用函数式编程的概念。如果你需要了解更多Lambda表达式的细节，可以参考官方文档。
2.2 接口的默认方法和静态方法
Java 8使用两个新概念扩展了接口的含义：默认方法和静态方法。默认方法使得接口有点类似traits，不过要实现的目标不一样。默认方法使得开发者可以在 不破坏二进制兼容性的前提下，往现存接口中添加新的方法，即不强制那些实现了该接口的类也同时实现这个新加的方法。
默认方法和抽象方法之间的区别在于抽象方法需要实现，而默认方法不需要。接口提供的默认方法会被接口的实现类继承或者覆写，例子代码如下：
private interface Defaulable {
// Interfaces now allow default methods, the implementer may or
// may not implement (override) them.
default String notRequired() {
return "Default implementation";
}
}
private static class DefaultableImpl implements Defaulable {
}
private static class OverridableImpl implements Defaulable {
@Override
public String notRequired() {
return "Overridden implementation";
}
}
Defaulable接口使用关键字default定义了一个默认方法notRequired()。DefaultableImpl类实现了这个接口，同时默认继承了这个接口中的默认方法；OverridableImpl类也实现了这个接口，但覆写了该接口的默认方法，并提供了一个不同的实现。
Java 8带来的另一个有趣的特性是在接口中可以定义静态方法，例子代码如下：
private interface DefaulableFactory {
// Interfaces now allow static methods
static Defaulable create( Supplier< Defaulable > supplier ) {
return supplier.get();
}
}
下面的代码片段整合了默认方法和静态方法的使用场景：
public static void main( String[] args ) {
Defaulable defaulable = DefaulableFactory.create( DefaultableImpl::new );
System.out.println( defaulable.notRequired() );
defaulable = DefaulableFactory.create( OverridableImpl::new );
System.out.println( defaulable.notRequired() );
}
这段代码的输出结果如下：
Default implementation
Overridden implementation
由于JVM上的默认方法的实现在字节码层面提供了支持，因此效率非常高。默认方法允许在不打破现有继承体系的基础上改进接口。该特性在官方库中的应用是：给java.util.Collection接口添加新方法，如stream()、parallelStream()、forEach()和removeIf()等等。
尽管默认方法有这么多好处，但在实际开发中应该谨慎使用：在复杂的继承体系中，默认方法可能引起歧义和编译错误。如果你想了解更多细节，可以参考官方文档。
2.3 方法引用
方法引用使得开发者可以直接引用现存的方法、Java类的构造方法或者实例对象。方法引用和Lambda表达式配合使用，使得java类的构造方法看起来紧凑而简洁，没有很多复杂的模板代码。
西门的例子中，Car类是不同方法引用的例子，可以帮助读者区分四种类型的方法引用。
public static class Car {
public static Car create( final Supplier< Car > supplier ) {
return supplier.get();
}
public static void collide( final Car car ) {
System.out.println( "Collided " + car.toString() );
}
public void follow( final Car another ) {
System.out.println( "Following the " + another.toString() );
}
public void repair() {
System.out.println( "Repaired " + this.toString() );
}
}
第一种方法引用的类型是构造器引用，语法是Class::new，或者更一般的形式：Class<T>::new。注意：这个构造器没有参数。
final Car car = Car.create( Car::new );
final List< Car > cars = Arrays.asList( car );
第二种方法引用的类型是静态方法引用，语法是Class::static_method。注意：这个方法接受一个Car类型的参数。
cars.forEach( Car::collide );
第三种方法引用的类型是某个类的成员方法的引用，语法是Class::method，注意，这个方法没有定义入参：
cars.forEach( Car::repair );
第四种方法引用的类型是某个实例对象的成员方法的引用，语法是instance::method。注意：这个方法接受一个Car类型的参数：
final Car police = Car.create( Car::new );
cars.forEach( police::follow );
运行上述例子，可以在控制台看到如下输出（Car实例可能不同）：
Collided com.javacodegeeks.java8.method.references.MethodReferences$Car@7a81197d
Repaired com.javacodegeeks.java8.method.references.MethodReferences$Car@7a81197d
Following the com.javacodegeeks.java8.method.references.MethodReferences$Car@7a81197d
如果想了解和学习更详细的内容，可以参考官方文档
2.4 重复注解
自从Java 5中引入注解以来，这个特性开始变得非常流行，并在各个框架和项目中被广泛使用。不过，注解有一个很大的限制是：在同一个地方不能多次使用同一个注解。Java 8打破了这个限制，引入了重复注解的概念，允许在同一个地方多次使用同一个注解。
在Java 8中使用@Repeatable注解定义重复注解，实际上，这并不是语言层面的改进，而是编译器做的一个trick，底层的技术仍然相同。可以利用下面的代码说明：
package com.javacodegeeks.java8.repeatable.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
public class RepeatingAnnotations {
@Target( ElementType.TYPE )
@Retention( RetentionPolicy.RUNTIME )
public @interface Filters {
Filter[] value();
}
@Target( ElementType.TYPE )
@Retention( RetentionPolicy.RUNTIME )
@Repeatable( Filters.class )
public @interface Filter {
String value();
};
@Filter( "filter1" )
@Filter( "filter2" )
public interface Filterable {
}
public static void main(String[] args) {
for( Filter filter: Filterable.class.getAnnotationsByType( Filter.class ) ) {
System.out.println( filter.value() );
}
}
}
正如我们所见，这里的Filter类使用@Repeatable(Filters.class)注解修饰，而Filters是存放Filter注解的容器，编译器尽量对开发者屏蔽这些细节。这样，Filterable接口可以用两个Filter注解注释（这里并没有提到任何关于Filters的信息）。
另外，反射API提供了一个新的方法：getAnnotationsByType()，可以返回某个类型的重复注解，例如Filterable.class.getAnnoation(Filters.class)将返回两个Filter实例，输出到控制台的内容如下所示：
filter1
filter2
如果你希望了解更多内容，可以参考官方文档。
2.5 更好的类型推断
Java 8编译器在类型推断方面有很大的提升，在很多场景下编译器可以推导出某个参数的数据类型，从而使得代码更为简洁。例子代码如下：
package com.javacodegeeks.java8.type.inference;
public class Value< T > {
public static< T > T defaultValue() {
return null;
}
public T getOrDefault( T value, T defaultValue ) {
return ( value != null ) ? value : defaultValue;
}
}
下列代码是Value<String>类型的应用：
package com.javacodegeeks.java8.type.inference;
public class TypeInference {
public static void main(String[] args) {
final Value< String > value = new Value<>();
value.getOrDefault( "22", Value.defaultValue() );
}
}
参数Value.defaultValue()的类型由编译器推导得出，不需要显式指明。在Java 7中这段代码会有编译错误，除非使用Value.<String>defaultValue()。
2.6 拓宽注解的应用场景
Java 8拓宽了注解的应用场景。现在，注解几乎可以使用在任何元素上：局部变量、接口类型、超类和接口实现类，甚至可以用在函数的异常定义上。下面是一些例子：
package com.javacodegeeks.java8.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.ArrayList;
import java.util.Collection;
public class Annotations {
@Retention( RetentionPolicy.RUNTIME )
@Target( { ElementType.TYPE_USE, ElementType.TYPE_PARAMETER } )
public @interface NonEmpty {
}
public static class Holder< @NonEmpty T > extends @NonEmpty Object {
public void method() throws @NonEmpty Exception {
}
}
@SuppressWarnings( "unused" )
public static void main(String[] args) {
final Holder< String > holder = new @NonEmpty Holder< String >();
@NonEmpty Collection< @NonEmpty String > strings = new ArrayList<>();
}
}
ElementType.TYPE_USER和ElementType.TYPE_PARAMETER是Java 8新增的两个注解，用于描述注解的使用场景。Java 语言也做了对应的改变，以识别这些新增的注解。
3. Java编译器的新特性
3.1 参数名称
为了在运行时获得Java程序中方法的参数名称，老一辈的Java程序员必须使用不同方法，例如Paranamer liberary。Java 8终于将这个特性规范化，在语言层面（使用反射API和Parameter.getName()方法）和字节码层面（使用新的javac编译器以及-parameters参数）提供支持。
package com.javacodegeeks.java8.parameter.names;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
public class ParameterNames {
public static void main(String[] args) throws Exception {
Method method = ParameterNames.class.getMethod( "main", String[].class );
for( final Parameter parameter: method.getParameters() ) {
System.out.println( "Parameter: " + parameter.getName() );
}
}
}
在Java 8中这个特性是默认关闭的，因此如果不带-parameters参数编译上述代码并运行，则会输出如下结果：
Parameter: arg0
如果带-parameters参数，则会输出如下结果（正确的结果）：
Parameter: args
如果你使用Maven进行项目管理，则可以在maven-compiler-plugin编译器的配置项中配置-parameters参数：
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<compilerArgument>-parameters</compilerArgument>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
4. Java官方库的新特性
Java 8增加了很多新的工具类（date/time类），并扩展了现存的工具类，以支持现代的并发编程、函数式编程等。
4.1 Optional
Java应用中最常见的bug就是空值异常。在Java 8之前，Google Guava引入了Optionals类来解决NullPointerException，从而避免源码被各种null检查污染，以便开发者写出更加整洁的代码。Java 8也将Optional加入了官方库。
Optional仅仅是一个容易：存放T类型的值或者null。它提供了一些有用的接口来避免显式的null检查，可以参考Java 8官方文档了解更多细节。
接下来看一点使用Optional的例子：可能为空的值或者某个类型的值：
Optional< String > fullName = Optional.ofNullable( null );
System.out.println( "Full Name is set? " + fullName.isPresent() );
System.out.println( "Full Name: " + fullName.orElseGet( () -> "[none]" ) );
System.out.println( fullName.map( s -> "Hey " + s + "!" ).orElse( "Hey Stranger!" ) );
如果Optional实例持有一个非空值，则isPresent()方法返回true，否则返回false；orElseGet()方法，Optional实例持有null，则可以接受一个lambda表达式生成的默认值；map()方法可以将现有的Opetional实例的值转换成新的值；orElse()方法与orElseGet()方法类似，但是在持有null的时候返回传入的默认值。
上述代码的输出结果如下：
Full Name is set? false
Full Name: [none]
Hey Stranger!
再看下另一个简单的例子：
Optional< String > firstName = Optional.of( "Tom" );
System.out.println( "First Name is set? " + firstName.isPresent() );
System.out.println( "First Name: " + firstName.orElseGet( () -> "[none]" ) );
System.out.println( firstName.map( s -> "Hey " + s + "!" ).orElse( "Hey Stranger!" ) );
System.out.println();
这个例子的输出是：
First Name is set? true
First Name: Tom
Hey Tom!
如果想了解更多的细节，请参考官方文档。
4.2 Streams
新增的Stream API（java.util.stream）将生成环境的函数式编程引入了Java库中。这是目前为止最大的一次对Java库的完善，以便开发者能够写出更加有效、更加简洁和紧凑的代码。
Steam API极大得简化了集合操作（后面我们会看到不止是集合），首先看下这个叫Task的类：
public class Streams {
private enum Status {
OPEN, CLOSED
};
private static final class Task {
private final Status status;
private final Integer points;
Task( final Status status, final Integer points ) {
this.status = status;
this.points = points;
}
public Integer getPoints() {
return points;
}
public Status getStatus() {
return status;
}
@Override
public String toString() {
return String.format( "[%s, %d]", status, points );
}
}
}
Task类有一个分数（或伪复杂度）的概念，另外还有两种状态：OPEN或者CLOSED。现在假设有一个task集合：
final Collection< Task > tasks = Arrays.asList(
new Task( Status.OPEN, 5 ),
new Task( Status.OPEN, 13 ),
new Task( Status.CLOSED, 8 )
);
首先看一个问题：在这个task集合中一共有多少个OPEN状态的点？在Java 8之前，要解决这个问题，则需要使用foreach循环遍历task集合；但是在Java 8中可以利用steams解决：包括一系列元素的列表，并且支持顺序和并行处理。
// Calculate total points of all active tasks using sum()
final long totalPointsOfOpenTasks = tasks
.stream()
.filter( task -> task.getStatus() == Status.OPEN )
.mapToInt( Task::getPoints )
.sum();
System.out.println( "Total points: " + totalPointsOfOpenTasks );
运行这个方法的控制台输出是：
Total points: 18
这里有很多知识点值得说。首先，tasks集合被转换成steam表示；其次，在steam上的filter操作会过滤掉所有CLOSED的task；第三，mapToInt操作基于每个task实例的Task::getPoints方法将task流转换成Integer集合；最后，通过sum方法计算总和，得出最后的结果。
在学习下一个例子之前，还需要记住一些steams（点此更多细节）的知识点。Steam之上的操作可分为中间操作和晚期操作。
中间操作会返回一个新的steam——执行一个中间操作（例如filter）并不会执行实际的过滤操作，而是创建一个新的steam，并将原steam中符合条件的元素放入新创建的steam。
晚期操作（例如forEach或者sum），会遍历steam并得出结果或者附带结果；在执行晚期操作之后，steam处理线已经处理完毕，就不能使用了。在几乎所有情况下，晚期操作都是立刻对steam进行遍历。
steam的另一个价值是创造性地支持并行处理（parallel processing）。对于上述的tasks集合，我们可以用下面的代码计算所有任务的点数之和：
// Calculate total points of all tasks
final double totalPoints = tasks
.stream()
.parallel()
.map( task -> task.getPoints() ) // or map( Task::getPoints )
.reduce( 0, Integer::sum );
System.out.println( "Total points (all tasks): " + totalPoints );
这里我们使用parallel方法并行处理所有的task，并使用reduce方法计算最终的结果。控制台输出如下：
Total points（all tasks）: 26.0
对于一个集合，经常需要根据某些条件对其中的元素分组。利用steam提供的API可以很快完成这类任务，代码如下：
// Group tasks by their status
final Map< Status, List< Task > > map = tasks
.stream()
.collect( Collectors.groupingBy( Task::getStatus ) );
System.out.println( map );
控制台的输出如下：
{CLOSED=[[CLOSED, 8]], OPEN=[[OPEN, 5], [OPEN, 13]]}
最后一个关于tasks集合的例子问题是：如何计算集合中每个任务的点数在集合中所占的比重，具体处理的代码如下：
// Calculate the weight of each tasks (as percent of total points)
final Collection< String > result = tasks
.stream() // Stream< String >
.mapToInt( Task::getPoints ) // IntStream
.asLongStream() // LongStream
.mapToDouble( points -> points / totalPoints ) // DoubleStream
.boxed() // Stream< Double >
.mapToLong( weigth -> ( long )( weigth * 100 ) ) // LongStream
.mapToObj( percentage -> percentage + "%" ) // Stream< String>
.collect( Collectors.toList() ); // List< String >
System.out.println( result );
控制台输出结果如下：
[19%, 50%, 30%]
最后，正如之前所说，Steam API不仅可以作用于Java集合，传统的IO操作（从文件或者网络一行一行得读取数据）可以受益于steam处理，这里有一个小例子：
final Path path = new File( filename ).toPath();
try( Stream< String > lines = Files.lines( path, StandardCharsets.UTF_8 ) ) {
lines.onClose( () -> System.out.println("Done!") ).forEach( System.out::println );
}
Stream的方法onClose 返回一个等价的有额外句柄的Stream，当Stream的close（）方法被调用的时候这个句柄会被执行。Stream API、Lambda表达式还有接口默认方法和静态方法支持的方法引用，是Java 8对软件开发的现代范式的响应。
4.3 Date/Time API(JSR 310)
Java 8引入了新的Date-Time API(JSR 310)来改进时间、日期的处理。时间和日期的管理一直是最令Java开发者痛苦的问题。java.util.Date和后来的java.util.Calendar一直没有解决这个问题（甚至令开发者更加迷茫）。
因为上面这些原因，诞生了第三方库Joda-Time，可以替代Java的时间管理API。Java 8中新的时间和日期管理API深受Joda-Time影响，并吸收了很多Joda-Time的精华。新的java.time包包含了所有关于日期、时间、时区、Instant（跟日期类似但是精确到纳秒）、duration（持续时间）和时钟操作的类。新设计的API认真考虑了这些类的不变性（从java.util.Calendar吸取的教训），如果某个实例需要修改，则返回一个新的对象。
我们接下来看看java.time包中的关键类和各自的使用例子。首先，Clock类使用时区来返回当前的纳秒时间和日期。Clock可以替代System.currentTimeMillis()和TimeZone.getDefault()。
// Get the system clock as UTC offset
final Clock clock = Clock.systemUTC();
System.out.println( clock.instant() );
System.out.println( clock.millis() );
这个例子的输出结果是：
2014-04-12T15:19:29.282Z
1397315969360
第二，关注下LocalDate和LocalTime类。LocalDate仅仅包含ISO-8601日历系统中的日期部分；LocalTime则仅仅包含该日历系统中的时间部分。这两个类的对象都可以使用Clock对象构建得到。
// Get the local date and local time
final LocalDate date = LocalDate.now();
final LocalDate dateFromClock = LocalDate.now( clock );
System.out.println( date );
System.out.println( dateFromClock );
// Get the local date and local time
final LocalTime time = LocalTime.now();
final LocalTime timeFromClock = LocalTime.now( clock );
System.out.println( time );
System.out.println( timeFromClock );
上述例子的输出结果如下：
2014-04-12
2014-04-12
11:25:54.568
15:25:54.568
LocalDateTime类包含了LocalDate和LocalTime的信息，但是不包含ISO-8601日历系统中的时区信息。这里有一些关于LocalDate和LocalTime的例子：
// Get the local date/time
final LocalDateTime datetime = LocalDateTime.now();
final LocalDateTime datetimeFromClock = LocalDateTime.now( clock );
System.out.println( datetime );
System.out.println( datetimeFromClock );
上述这个例子的输出结果如下：
2014-04-12T11:37:52.309
2014-04-12T15:37:52.309
如果你需要特定时区的data/time信息，则可以使用ZoneDateTime，它保存有ISO-8601日期系统的日期和时间，而且有时区信息。下面是一些使用不同时区的例子：
// Get the zoned date/time
final ZonedDateTime zonedDatetime = ZonedDateTime.now();
final ZonedDateTime zonedDatetimeFromClock = ZonedDateTime.now( clock );
final ZonedDateTime zonedDatetimeFromZone = ZonedDateTime.now( ZoneId.of( "America/Los_Angeles" ) );
System.out.println( zonedDatetime );
System.out.println( zonedDatetimeFromClock );
System.out.println( zonedDatetimeFromZone );
这个例子的输出结果是：
2014-04-12T11:47:01.017-04:00[America/New_York]
2014-04-12T15:47:01.017Z
2014-04-12T08:47:01.017-07:00[America/Los_Angeles]
最后看下Duration类，它持有的时间精确到秒和纳秒。这使得我们可以很容易得计算两个日期之间的不同，例子代码如下：
// Get duration between two dates
final LocalDateTime from = LocalDateTime.of( 2014, Month.APRIL, 16, 0, 0, 0 );
final LocalDateTime to = LocalDateTime.of( 2015, Month.APRIL, 16, 23, 59, 59 );
final Duration duration = Duration.between( from, to );
System.out.println( "Duration in days: " + duration.toDays() );
System.out.println( "Duration in hours: " + duration.toHours() );
这个例子用于计算2014年4月16日和2015年4月16日之间的天数和小时数，输出结果如下：
Duration in days: 365
Duration in hours: 8783
对于Java 8的新日期时间的总体印象还是比较积极的，一部分是因为Joda-Time的积极影响，另一部分是因为官方终于听取了开发人员的需求。如果希望了解更多细节，可以参考官方文档。
4.4 Nashorn JavaScript引擎
Java 8提供了新的Nashorn JavaScript引擎，使得我们可以在JVM上开发和运行JS应用。Nashorn JavaScript引擎是javax.script.ScriptEngine的另一个实现版本，这类Script引擎遵循相同的规则，允许Java和JavaScript交互使用，例子代码如下：
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName( "JavaScript" );
System.out.println( engine.getClass().getName() );
System.out.println( "Result:" + engine.eval( "function f() { return 1; }; f() + 1;" ) );
这个代码的输出结果如下：
jdk.nashorn.api.scripting.NashornScriptEngine
Result: 2
4.5 Base64
对Base64编码的支持已经被加入到Java 8官方库中，这样不需要使用第三方库就可以进行Base64编码，例子代码如下：
package com.javacodegeeks.java8.base64;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
public class Base64s {
public static void main(String[] args) {
final String text = "Base64 finally in Java 8!";
final String encoded = Base64
.getEncoder()
.encodeToString( text.getBytes( StandardCharsets.UTF_8 ) );
System.out.println( encoded );
final String decoded = new String(
Base64.getDecoder().decode( encoded ),
StandardCharsets.UTF_8 );
System.out.println( decoded );
}
}
这个例子的输出结果如下：
QmFzZTY0IGZpbmFsbHkgaW4gSmF2YSA4IQ==
Base64 finally in Java 8!
新的Base64API也支持URL和MINE的编码解码。
(Base64.getUrlEncoder() / Base64.getUrlDecoder(), Base64.getMimeEncoder() / Base64.getMimeDecoder())。
4.6 并行数组
Java8版本新增了很多新的方法，用于支持并行数组处理。最重要的方法是parallelSort()，可以显著加快多核机器上的数组排序。下面的例子论证了parallexXxx系列的方法：
package com.javacodegeeks.java8.parallel.arrays;
import java.util.Arrays;
import java.util.concurrent.ThreadLocalRandom;
public class ParallelArrays {
public static void main( String[] args ) {
long[] arrayOfLong = new long [ 20000 ];
Arrays.parallelSetAll( arrayOfLong,
index -> ThreadLocalRandom.current().nextInt( 1000000 ) );
Arrays.stream( arrayOfLong ).limit( 10 ).forEach(
i -> System.out.print( i + " " ) );
System.out.println();
Arrays.parallelSort( arrayOfLong );
Arrays.stream( arrayOfLong ).limit( 10 ).forEach(
i -> System.out.print( i + " " ) );
System.out.println();
}
}
上述这些代码使用parallelSetAll()方法生成20000个随机数，然后使用parallelSort()方法进行排序。这个程序会输出乱序数组和排序数组的前10个元素。上述例子的代码输出的结果是：
Unsorted: 591217 891976 443951 424479 766825 351964 242997 642839 119108 552378
Sorted: 39 220 263 268 325 607 655 678 723 793
4.7 并发性
基于新增的lambda表达式和steam特性，为Java 8中为java.util.concurrent.ConcurrentHashMap类添加了新的方法来支持聚焦操作；另外，也为java.util.concurrentForkJoinPool类添加了新的方法来支持通用线程池操作（更多内容可以参考我们的并发编程课程）。
Java 8还添加了新的java.util.concurrent.locks.StampedLock类，用于支持基于容量的锁——该锁有三个模型用于支持读写操作（可以把这个锁当做是java.util.concurrent.locks.ReadWriteLock的替代者）。
在java.util.concurrent.atomic包中也新增了不少工具类，列举如下：
DoubleAccumulator
DoubleAdder
LongAccumulator
LongAdder
5. 新的Java工具
Java 8提供了一些新的命令行工具，这部分会讲解一些对开发者最有用的工具。
5.1 Nashorn引擎：jjs
jjs是一个基于标准Nashorn引擎的命令行工具，可以接受js源码并执行。例如，我们写一个func.js文件，内容如下：
function f() {
return 1;
};
print( f() + 1 );
可以在命令行中执行这个命令：jjs func.js，控制台输出结果是：
2
如果需要了解细节，可以参考官方文档。
5.2 类依赖分析器：jdeps
jdeps是一个相当棒的命令行工具，它可以展示包层级和类层级的Java类依赖关系，它以.class文件、目录或者Jar文件为输入，然后会把依赖关系输出到控制台。
我们可以利用jedps分析下Spring Framework库，为了让结果少一点，仅仅分析一个JAR文件：org.springframework.core-3.0.5.RELEASE.jar。
jdeps org.springframework.core-3.0.5.RELEASE.jar
这个命令会输出很多结果，我们仅看下其中的一部分：依赖关系按照包分组，如果在classpath上找不到依赖，则显示"not found".
org.springframework.core-3.0.5.RELEASE.jar -> C:\Program Files\Java\jdk1.8.0\jre\lib\rt.jar
org.springframework.core (org.springframework.core-3.0.5.RELEASE.jar)
-> java.io
-> java.lang
-> java.lang.annotation
-> java.lang.ref
-> java.lang.reflect
-> java.util
-> java.util.concurrent
-> org.apache.commons.logging not found
-> org.springframework.asm not found
-> org.springframework.asm.commons not found
org.springframework.core.annotation (org.springframework.core-3.0.5.RELEASE.jar)
-> java.lang
-> java.lang.annotation
-> java.lang.reflect
-> java.util
更多的细节可以参考官方文档。
6. JVM的新特性
使用Metaspace（JEP 122）代替持久代（PermGen space）。在JVM参数方面，使用-XX:MetaSpaceSize和-XX:MaxMetaspaceSize代替原来的-XX:PermSize和-XX:MaxPermSize。
7. 结论
通过为开发者提供很多能够提高生产力的特性，Java 8使得Java平台前进了一大步。现在还不太适合将Java 8应用在生产系统中，但是在之后的几个月中Java 8的应用率一定会逐步提高（PS:原文时间是2014年5月9日，现在在很多公司Java 8已经成为主流，我司由于体量太大，现在也在一点点上Java 8，虽然慢但是好歹在升级了）。作为开发者，现在应该学习一些Java 8的知识，为升级做好准备。
关于Spring：对于企业级开发，我们也应该关注Spring社区对Java 8的支持，可以参考这篇文章——Spring 4支持的Java 8新特性一览
8. 参考资料
What’s New in JDK 8
The Java Tutorials
WildFly 8, JDK 8, NetBeans 8, Java EE
Java 8 Tutorial
JDK 8 Command-line Static Dependency Checker
The Illuminating Javadoc of JDK
The Dark Side of Java 8
Installing Java™ 8 Support in Eclipse Kepler SR2
Java 8
Oracle Nashorn. A Next-Generation JavaScript Engine for the JVM
Java 8 更新
| 版本 | 釋出日期 | 重點 |
|---|---|---|
| Java SE 8 | 2014-03-18 | 初始版本 |
| Java SE 8 Update 5[206] | 2014-04-15 | 使用「*」在 Caller-Allowable-Codebase 屬性中; 11個漏洞的修補 |
| Java SE 8 Update 11[207] | 2014-07-15 | Java 依賴性分析工具（Java Dependency Analysis Tool）; Java 控制台選項以禁用贊助者; JAR 檔案屬性 – Entry-Point; JAXP 處理限制屬性 – maxElementDepth; 18 個安全性漏洞修補,[208] 15 個漏洞修補 |
| Java SE 8 Update 20[209] | 2014-08-19 | 669 個漏洞修補，[210] JMC 5.4, 字串重複數據刪除（預設為不啟用） |
| Java SE 8 Update 25[211] | 2014-10-14 | 10 個漏洞修補 |
| Java SE 8 Update 31[212] | 2015-01-19 | 26 個漏洞修補; SSLv3 (預設為禁用) |
| Java SE 8 Update 40[213] | 2015-03-03 | 645 個漏洞修補,[214] 加入「記憶體壓力」的概念來協助指出有多少的系統記憶體還能夠使用(低壓 = 高記憶體, 高壓 = 低記憶體) |
| Java SE 8 Update 45[215] | 2015-04-14 | 13 個漏洞修補 |
| Java SE 8 Update 51[216] | 2015-07-14 | 增加對WIndows平台的原生沙盒的支援（預設為禁用）; 另外還有 25 個安全性修補,14 個漏洞修補 |
| Java SE 8 Update 60[217] | 2015-08-18 | 480 個漏洞修補[218] |
| Java SE 8 Update 65[219] | 2015-10-20 | 25 個安全性修補, 3 個漏洞修補 |
| Java SE 8 Update 66[220] | 2015-11-16 | 15 個漏洞修補 |
| Java SE 8 Update 71[221] | 2016-01-19 | 8 個安全性修補, 5 個漏洞修補[222] |
| Java SE 8 Update 72 | 2016-01-19 | 8 個安全性修補, 5 個漏洞修補, 許多的增強 |
| Java SE 8 Update 73[223] | 2016-02-03 | 1 個安全性修補 |
| Java SE 8 Update 74[224] | 2016-02-03 | 1 個安全性修補 |
| Java SE 8 Update 77[225] | 2016-03-23 | 1 個安全性修補 |
| Java SE 8 Update 91[226] | 2016-04-19 | 9 個安全性修補, 4 個漏洞修補和增強 |
| Java SE 8 Update 92[227] | 2016-04-19 | 來自8u91的安全性和漏洞修補, 再加上 76 個額外的漏洞消補; 推出 ExitOnOutOfMemoryError 和CrashOnOutOfMemoryError 標籤 |
| Java SE 8 Update 101[228] | 2016-07-19 | 來自8u92的安全性和漏洞修補, 再加上 9個額外的漏洞消補 |
| Java SE 8 Update 102[229] | 2016-07-19 | 來自8u101的安全性和漏洞修補, 再加上 118 個額外的漏洞消補 |
| Java SE 8 Update 111[230] | 2016-10-18 | 安全性修補和 9 個漏洞修補 |
| Java SE 8 Update 112[231] | 2016-10-18 | 新增功能和139個漏洞修補在8u111 |
Java SE 9
在2011年的JavaOne中，Oracle討論了一些他們希望在2016年釋出Java 9的功能，[232]包含對於多GB級堆疊更好的支援，更好的原生原始碼整合性，還有能夠自我協調（Self-tuning）的JVM.[233] 在2016年初，Java 9的釋出日期被改到了2017年3月，又被拖延了4個月到2017年7月。[234]
-
JSR 376：在Jigsaw專案中將JDK模組化 (Java Module System)[235][236][237]
-
JEP 295：Ahead-of-Time Compilation[240]
-
JEP 268：XML Catalogs[241]
工作正在進行之中，使 JAVA 執行的反應流部分的 JAVA 9︰JSR 166 的領導者 Doug Lea提出了一個新的「Flow」類別，將包括目前的反應流提供的介面。這項工作被記錄下︰
-
JEP 266：更多的併發更新[242]
1030
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
