Java 七 中的新功能[翻译]
Java7 中有一些令开发者很高兴的新特性，如switch语句中的使用字符串作为表达式，多catch异常处理，try-with-resources (自动资源管理)，新的文件系统API， jvm扩展，支持动态类型语言，支持并行任务的fork/join框架，以及其他一些肯定会被社区支持的特性。
下面就概述以上功能，并提供适当的例子。 这里可以下载一个zip文件，其中包含在这篇文章中的代码片段。
语言增强
Java7 通过Project Coin 提供了一些新的语言特性，这些功能对开发者来说非常方便。
Diamond Operator
你可能已经注意到在使用泛型的时候，IDE经常会出现警告提示。例如，如果我们要声明一个使用trades类作为泛型的Map类时，我们会写出像下面的代码：
Map<String, List<Trade>> trades = new TreeMap<String, List<Trade>> ();
我们必须在等号两边都声明同样的类型，这并不是一件很方便的事情，显然右边的声明看上去有些多余。编译器能根据左边的声明推断右边的类型吗？之前是不行的，在Java7中的代码可以写成下面的样子：
Map<String, List<Trade>> trades = new TreeMap <> ();
是不是很酷？你不需要输入实例类型的完整列表。相反，你使用<>符号，这就是所谓的钻石操作符，请注意，虽然没有声明的钻石操作符是合法的， trades = new TreeMap () ），但它会使编译器生成几个类型安全警告。
在switch语句中使用的字符串
之前的switch语句只能使用原始数据类型或枚举类型。Java 7中引入另一种类型，我们可以在switch语句中使用字符串String类型。
假设我们需要根据状态处理一个交易， 到现在为止，我们使用if - else语句。
private void processTrade(Trade t) {
String status = t.getStatus();
if (status.equalsIgnoreCase(NEW)) {
newTrade(t);
} else if (status.equalsIgnoreCase(EXECUTE)) {
executeTrade(t);
} else if (status.equalsIgnoreCase(PENDING)) {
pendingTrade(t);
}
}
这是一种很粗糙的处理方法，在Java 7中，我们可以利用增强的switch语句，使用String作为参数
public void processTrade(Trade t) {
String status = t.getStatus();
switch (status) {
case NEW:
newTrade(t);
break;
case EXECUTE:
executeTrade(t);
break;
case PENDING:
pendingTrade(t);
break;
default:
break;
}
}
在上面的程序中，状态字段总是使用String.equals() 方法和case标签进行比较。
Automatic resource management
像连接、文件、I/O流一些的资源都需要开发者编写代码手动的关闭，通常我们使用try-finally块负责关闭各自的资源。目前常用的实现如下：
public void oldTry() {
try {
fos = new FileOutputStream("movies.txt");
dos = new DataOutputStream(fos);
dos.writeUTF("Java 7 Block Buster");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fos.close();
dos.close();
} catch (IOException e) {
// log the exception
}
}
}
然而，Java 7中引入了另一个很酷的功能，自动管理资源。 它操作非常简单。 我们要做的是在try中声明资源，如下：
try(resources_to_be_cleant){
// your code
}
前面的方法oldtry可以使用新功能改写成如下：
public void newTry() {
try (FileOutputStream fos = new FileOutputStream("movies.txt");
DataOutputStream dos = new DataOutputStream(fos)){
dos.writeUTF("Java 7 Block Buster");
}catch (IOException e) {
// log the exception
}
}
上面的代码，也代表此功能的另一个方面：与多个资源的工作。 FileOutputStream和DataOutputStream资源都包含在try语句中一前一后，每一个资源分别由分号分隔（;）。我们不需要去手动的废除或关闭资源，它们会在控制推出try语言块后自动的在后台关闭。需要被自动关闭的资源必须实现java.lang.AutoCloseable接口。
任何实现AutoCloseable接口的资源都会被作为自动资源管理的对象， AutoCloseable是java.io.Closeable 接口的父类，只有close()一个方法，当程序控制推出try语言块时，该方法会被jvm调用。
数字文字用下划线
数值文字是眼睛过滤器。如果给你一个带有十个零的数，我相信你一定会像我一样的开始计算零的个数。识别一个百万甚至千万的数是很容易出错，而且繁琐的。在Java7中可以再确定的地方引入强调符号，例如你可以像下面的方式声明一千：
int thousand = 1_000;
或者一百万
int million = 1_000_000
注意：此版本也引入了binary 二进制文字，开发人员再也不必将它们转换为十六进制了，例如“0B1”。
改进的异常处理
在异常处理方面也有一些改进。Java7引入了多重捕获功能(multi-catch)，可以再一个catch块中捕获多种不同类型的异常。
例如，你有一个方法会抛出三个异常，按之前的处理，你需要像下面这样分别处理各个异常：
public void oldMultiCatch() {
try {
methodThatThrowsThreeExceptions();
} catch (ExceptionOne e) {
// log and deal with ExceptionOne
} catch (ExceptionTwo e) {
// log and deal with ExceptionTwo
} catch (ExceptionThree e) {
// log and deal with ExceptionThree
}
}
在catch块中捕获一个又一个的异常，看起来非常杂乱。如代码所示捕获一堆异常，效率非常低下，而且容易出错。 Java 7中带来了一种新的语言变化，来解决这个丑小鸭。 来看看方法的改进版本oldMultiCatch方法如下：
public void newMultiCatch() {
try {
methodThatThrowsThreeExceptions();
} catch (ExceptionOne | ExceptionTwo | ExceptionThree e) {
/ log and deal with all Exceptions
}
}
多个异常在一个catch块中捕获，不同的异常之间用(|)操作符分隔开。使用这种方法你就不需要写许多的捕获异常块。而且，如果你有许多属于不同类型的异常，你可以使用多个multi-catch块， 下面的代码片段说明了这一点：
public void newMultiMultiCatch() {
try {
methodThatThrowsThreeExceptions();
} catch (ExceptionOne e) {
// log and deal with ExceptionOne
} catch (ExceptionTwo | ExceptionThree e) {
// log and deal with ExceptionTwo and ExceptionThree
}
}
在上述案例中，ExceptionTwo和ExceptionThree属于不同层次，所以你会想用一个catch块的不同方法来处理它们。
新的文件系统 API (NIO 2.0)
使用过Java IO的人可能任然记得框架带来的麻烦。 跨操作系统或者多文件系统的无缝使用从来都不一件容易的事情。像删除文件、重命名一类的动作在很多时候都会引起不可意料的结果。 使用符号链接是另一个问题。 总地来说，API需要大修。
为了解决上述Java的IO问题，Java 7的推出了新的API。NIO 2.0带来了许多新的改进，也引入了新的类，方便开发人员处理多文件系统问题。
文件路径
新java.nio.file的包中包含Path， Paths ，FileSystem，FileSystems和其他如类和接口。
Path是一个简单的引用文件的路径。 它是等价（更多的功能） java.io.File 。 下面的代码片断演示了如何获得“Temp”文件夹的路径引用：
public void pathInfo() {
Path path = Paths.get("c:\\Temp\\temp");
System.out.println("Number of Nodes:" + path.getNameCount());
System.out.println("File Name:" + path.getFileName());
System.out.println("File Root:" + path.getRoot());
System.out.println("File Parent:" + path.getParent());
}
控制台会输出如下内容：
Number of Nodes:2 File Name:temp.txt File Root:c:\ File Parent:c:\Temp
删除一个文件或目录只需要简单的调Files类的delete方法（注意复数）。 Files类公开了两个delete方法，其中一个会抛出NoSuchFileException 另一个则不会。
下面的删除方法调用抛出NoSuchFileException的，所以你必须处理它：
Files.delete(path);
如果文件或目录不存在，Files.deleteIfExists(path) 不会抛出异常。
您可以使用Files.copy(..)和Files.move(..)等通用方法对文件系统进行操作。 同样，使用createSymbolicLink(..)方法创建符号链接。
文件更改通知
在JDK 7，我最喜欢的改善之一，是增加了文件更改通知。 这一直是期待已久的的功能，终于雕刻成NIO 2.0。WatchService API使你会在对象（目录或文件）变化后收到事件通知。
实现API所涉及的步骤是：
· 创建一个WatchService 。 这项服务包括一个持有WatchKeys的队列
· 用这个WatchService注册要监视的目录/文件
· 注册时，指定您希望收到的事件的类型（创建，修改或删除事件）
· 开始一个无限循环监听事件
· 当事件发生时，一个WatchKey被放入队列
· 消耗WatchKey ，并调用它的查询
通过一个例子。 我们创建一个DirPolice Java程序，其责任是检测一个特定的目录。 步骤如下：
1、创建WatchService对象：
WatchService watchService = FileSystems.getDefault().newWatchService();
2、获取到你监视的目录的路径引用。 我建议你把这个目录的参数化，所以你不要硬编码文件名；
path = Paths.get("C:\\Temp\\temp\\");
3、下一步是用WatchService为该目录注册所有类型的事件：
dirToWatch.register(watchService, ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE);
这是java.nio.file.StandardWatchEventKind 事件类型
4、启动无限循环，并开始接受的事件：
while(true){
WatchKey key = watchService.take(); // this would return you keys
…
}
5、通过对关键事件的运行：
for(WatchEvent<?> event : key.pollEvents()) {
Kind<?> kind = event.kind();
System.out.println("Event on " + event.context().toString() + " is " + kind);
}
例如，如果你修改或删除这个临时文件夹，你会在控制台看到入下输出:
Event on temp is ENTRY_MODIFY Event on temp is ENTRY_DELETE
DirPolice相关方法源代码如下（ 下载完整的源代码 ）：
try {
watchService = FileSystems.getDefault().newWatchService();
path.register(watchService, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
} catch (IOException e) {
System.out.println("IOException"+ e.getMessage());
}
/**
* The police will start making rounds
*/
private void doRounds() {
WatchKey key = null;
while(true) {
try {
key = watchService.take();
for(WatchEvent<?> event : key.pollEvents()) {
Kind<?> kind = event.kind();
System.out.println("Event on " + event.context().toString() + " is " + kind);
}
} catch (InterruptedException e) {
System.out.println("InterruptedException: "+e.getMessage());
}
boolean reset = key.reset();
if(!reset)
break;
}
}
Fork and Join
在java程序中有效的使用并行内核一直是一个挑战，有一些框架将任务分派到多核上执行，然后合并返回的结果集。Java7纳入这个功能，提供一个fork/join框架。
总地来说，Fork-Join 把待处理的任务逐级分解成小任务，直到所有任务都已经足够简单不需要再分解。它就像一个分治算法。这个框架中的一个重要的概念是最好没有工作线程处于空闲状态。 它实现了工作-窃取算法，空闲线程会从繁忙的工作线程处“窃取”任务。
支持fork-join机制的核心类是ForkJoinPool和ForkJoinTask 。 ForkJoinPool基本上是一个ExecutorService的特别实现类，执行我们上面谈到的工作窃取算法。
我们创建一个ForkJoinPool的实例，提供目标并行级别——处理器的数量，如下所示：
ForkJoinPool pool = new ForkJoinPool(numberOfProcessors) numberOfProcessors = Runtime.getRunTime().availableProcessors();
但是，默认的ForkJoinPool实例需要设置并行级别为上面获得相同数量。
需要解决的问题写在ForkJoinTask里。 但是，有两个实现类：RecursiveAction和RecursiveTask，这两个类之间的唯一区别是，前者不返回值，而后者则返回指定类型的对象。
以下是如何创建RecursiveTask或RecursiveAction处理前面提到的问题（我使用 RecursiveAction类）
public class MyBigProblemTask extends RecursiveAction {
@Override
protected void compute() {
. . . // your problem invocation goes here
}
}
你必须覆盖需要提供计算功能的方法。 现在，向Executor提供ForkJoinTask，通过调用ForkJoinPool的invoke方法：
pool.invoke(task);
支持动态语言
Java是一种静态类型的语言 ——变量，方法和返回值的类型检查是在编译时进行。 JVM在运行时执行强类型的字节码，而不必担心找到的类型信息。
还有另一种类型的语言品种 - 动态语言。 Ruby，Python和Clojure的都属于这一类。 类型信息在运行时才能确定。 这是不是可能在Java，因为它不会有任何必要的类型信息。
Java 7中，推出的一项称为invokedynamic的新功能。 这使得虚拟机的变化，纳入非Java语言的要求。已经创建了一个新的软件包， java.lang.invoke ， MethodHandle ， CallSite和其他人组成的，如类，扩展动态语言的支持。
原文地址
http://radar.oreilly.com/2011/09/java7-features.html