正文

Java 8 特性 – 终极手册

IP云
IP云V管理员/5 阅读
11/25
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

简介

毫无疑问，Java 8的发布是自Java 5（它的发布已远在2004年）以来在Java世界中最重大的事情。它带来了超多的新特性，这些特性分别被加入到Java语言本身、Java编译器、类库、工具类和JVM（Java虚拟机）。在这篇入门指南中，我们将概览所有的改变，同时也会通过实例演示一下它们的不同使用场景。

这篇指南包含如下几部分，每一部分都分别剖析其具体特性：

  • 语言
  • 编译器
  • 类库
  • 工具类
  • 运行时 (JVM)

2. Java语言的新特性

无论从哪方面来说Java 8都是一个重大版本。也许有人会说，为了加入这个每一个Java开发者都期望的新特性耗费了太长时间。在本节我们将谈谈这些新特性。

2.1. Lambda表达式和函数式接口

Lambda表达式（也叫闭包）是整个Java 8版本中最大和最令人期待的语言改进。它使得我们可以将函数作为方法的参数（传递函数），或者将代码看作数据：这是每一个函数式开发者都非常熟知的概念。很多基于JVM平台的语言（如Groovy，Scala等），都是在语言的诞生之初就支持lambda表达式；但是对于Java开发者来说，别无选择，只能使用繁冗的匿名类来替代lambda表达式。

Lambda表达式的设计讨论了很久，也耗费了大量社区的精力。不过最终总算获得了折中的方法，从而建立一个新的更为简洁、紧凑的语言结构。在其最简单的形式中，lambda表达式可以表示为以逗号分隔的列表-含有不同参数、一个->符号、和代码块。例如：

1 Arrays.asList( "a" , "b" , "d" ).forEach( e -> System.out.println( e ) );

请注意这里的参数 e 的类型是由编译器自动推导出的。另外，你也可以显式的指明参数的类型，只需使用括弧将其定义包起来。例如：

1 Arrays.asList( "a" , "b" , "d" ).forEach( ( String e ) -> System.out.println( e ) );

如果lambda的代码块太过复杂，也可以使用花括号包裹起来，就像定义普通的Java方法一样。例如：

1 Arrays.asList( "a" , "b" , "d" ).forEach( e -> {
2 System.out.print( e );
3 System.out.print( e );
4 } );

Lambda表达式也可以引用类成员变量和本地变量（如果不是 final 的话会被隐式设置为“有效 final ”）。举例来说，下面两段代码是等价的：

1 String separator = "," ;
2 Arrays.asList( "a" , "b" , "d" ).forEach(
3 ( String e ) -> System.out.print( e + separator ) );

和:

1 final String separator = "," ;
2 Arrays.asList( "a" , "b" , "d" ).forEach(
3 ( String e ) -> System.out.print( e + separator ) );

Lambda表达式也可以有返回值。返回值的类型将由编译器自动推导得出。如果lambda的代码块只有一行的话， return 语句不是必需的。下面两种写法是等价的：

1 Arrays.asList( "a" , "b" , "d" ).sort( ( e1, e2 ) -> e1.compareTo( e2 ) );

和:

1 Arrays.asList( "a" , "b" , "d" ).sort( ( e1, e2 ) -> {
2 int result = e1.compareTo( e2 );
3 return result;
4 } );

语言设计者们考虑了很多如何才能使得已有功能能够和lambda表达式友好兼容。由此，函数式接口的概念应运而生。函数式接口是一种只有一个方法的接口；这样，它可以被隐式的转换为lambda表达式。 java.lang.Runnable 和 java.uril.concurrent.Callable 是函数式接口的两个典型示例. 但是在实践中，函数式接口是脆弱的：如果有人在接口定义中又加入了一个方法，那么它就不再是一个函数式接口了，而且会导致编译过程失败。为了克服这种脆弱性，同时又能显式声明一个接口是函数式接口，Java 8新增了一种特别的注解@FuncionalInterface(Java类库中的所有的已有接口都已经加上了@FunctionalInteface注解)。我们来看一看如何定义简单的函数式接口：

1 @FunctionalInterface
2 public interface Functional {
3 void method();
4 }

有一点需要注意：默认方法和静态方法不会对函数式接口有任何影响，举个例子：

1 @FunctionalInterface
2 public interface FunctionalDefaultMethods {
3 void method();
4
5 default void defaultMethod() {
6 }
7 }

Lambda是Java 8的最大卖点。它拥有巨大的潜力，来吸引越来越多的开发人员加入到这个伟大的平台；并且对纯Java中的函数式编程概念给予最大的支持。更多信息请参考官方文档。

2.2. 接口的默认方法和静态方法

Java 8从两个概念扩展了接口的定义：默认方法和静态方法。默认方法使得接口有点类似于Traits语法但是面向的目标不同。它允许添加新方法到已有接口中，但是不会破坏那些基于老版接口实现的代码的二进制兼容性。

默认方法和抽象方法的区别在于：抽象方法是必须要实现的，而默认方法不是。相反，每个接口必须提供一个所谓的默认方法实现，所有的实现类都会默认继承得到这个方法（如果需要也可以重写这个默认实现）。我们来看看下面这个例子：

01 private interface Defaulable {
02 // Interfaces now allow default methods, the implementer may or
03 // may not implement (override) them.
04 default String notRequired() {
05 return "Default implementation" ;
06 }
07 }
08
09 private static class DefaultableImpl implements Defaulable {
10 }
11
12 private static class OverridableImpl implements Defaulable {
13 @Override
14 public String notRequired() {
15 return "Overridden implementation" ;
16 }
17 }

接口 Defaulable 在定义中使用关键字 default 声明了一个默认方法 notRequired() 。有一个类 DefaultableImpl 实现了这个接口，它没有对默认方法做任何更改。另一个类 OverridableImpl ，则重写了接口中的默认实现，实现了自己的逻辑。

Java 8提供的另一个很有意思的特性是接口可以声明静态方法（同时提供实现）。举个例子：

1 private interface DefaulableFactory {
2 // Interfaces now allow static methods
3 static Defaulable create( Supplier< Defaulable > supplier ) {
4 return supplier.get();
5 }
6 }

下面这段代码将之前例子中提到的默认方法和静态方法放在了一起：

1 public static void main( String[] args ) {
2 Defaulable defaulable = DefaulableFactory.create( DefaultableImpl:: new );
3 System.out.println( defaulable.notRequired() );
4
5 defaulable = DefaulableFactory.create( OverridableImpl:: new );
6 System.out.println( defaulable.notRequired() );
7 }

这个程序的控制台输出如下：

1 Default implementation
2 Overridden implementation

JVM中默认方法的实现非常高效，而且方法调用的字节码指令支持默认方法。默认方法使得已有的Java接口能够改进而不会导致编译过程失败。接口 java.util.Collection 中新增了大量的方法，都是很好的示例，如： stream() , parallelStream() , forEach() , removeIf() ,等等。

虽然默认方法很强大，我们还是要谨慎使用它：在将一个方法定义为default方法之前，最好三思是不是必须要这么做，因为它可能在层级复杂的情况下引起歧义和编译错误。更多信息请参考官方文档。

2.3. 方法引用

方法引用提供了一种很有用的语法，来直接引用Java类或者对象（实例）中的已有方法或者构造函数。将方法引用和Lambda表达式结合起来使用，可以使得语言结构更加紧凑整洁，不需要再使用任何复杂的引用代码。

下面让我们以 Car 类为例来说明不同的方法定义，看看4种支持的方法引用类型。

01 public static class Car {
02 public static Car create( final Supplier< Car > supplier ) {
03 return supplier.get();
04 }
05
06 public static void collide( final Car car ) {
07 System.out.println( "Collided " + car.toString() );
08 }
09
10 public void follow( final Car another ) {
11 System.out.println( "Following the " + another.toString() );
12 }
13
14 public void repair() {
15 System.out.println( "Repaired " + this .toString() );
16 }
17 }

第一种方法引用类型是构造函数引用，格式是 Class::new ； 也可以使用泛型， Class<T>::new 。请注意这里的构造函数是无参的。

1 final Car car = Car.create( Car:: new );
2 final List< Car > cars = Arrays.asList( car );

第二种类型是静态方法引用，格式为 Class::static_method 。请注意这里的方法只接受一个 Car 类型的参数。

1 cars.forEach( Car::collide );

第三种类型是对特定类型的任意对象的实例方法的引用，格式为 Class::method 。请注意，这个方法不能带有任何参数。

1 cars.forEach( Car::repair );

最后一种类型是对特定类型对象的实例方法的引用，格式为 instance::method 。请注意这个方法只接受一个 Car 类型的参数。

1 final Car police = Car.create( Car:: new );
2 cars.forEach( police::follow );

运行上面的Java程序，在控制台会看到如下输出（实际的 Car 实例可能会有不同）：

1 Collided com.javacodegeeks.java8.method.references.MethodReferences$Car @7a81197d
2 Repaired com.javacodegeeks.java8.method.references.MethodReferences$Car @7a81197d
3 Following the com.javacodegeeks.java8.method.references.MethodReferences$Car @7a81197d

关于方法引用的更多示例和细节请参考官方文档。

2.4. 重复型注解

自从Java5引入对注解的支持，这个特性已经变得越来越受欢迎而且被广泛应用。不过，对注解的使用有一个限制，就是同一个注解不能在同一个位置多次声明。Java 8打破了这个限制，引入了重复型注解(repeating annotations)，它支持在注解声明的位置，可以多次声明相同的注解。

重复型注解自身应该被注解为@Repeatable。事实上，这并不是一个语言层面的变化，而更像是编译器层面的“小把戏”，因为从技术层面来说是完全一样的。我们通过一个简单的例子来看看：

01 package com.javacodegeeks.java8.repeatable.annotations;
02
03 import java.lang.annotation.ElementType;
04 import java.lang.annotation.Repeatable;
05 import java.lang.annotation.Retention;
06 import java.lang.annotation.RetentionPolicy;
07 import java.lang.annotation.Target;
08
09 public class RepeatingAnnotations {
10 @Target ( ElementType.TYPE )
11 @Retention ( RetentionPolicy.RUNTIME )
12 public @interface Filters {
13 Filter[] value();
14 }
15
16 @Target ( ElementType.TYPE )
17 @Retention ( RetentionPolicy.RUNTIME )
18 @Repeatable ( Filters. class )
19 public @interface Filter {
20 String value();
21 };
22
23 @Filter ( "filter1" )
24 @Filter ( "filter2" )
25 public interface Filterable {
26 }
27
28 public static void main(String[] args) {
29 for ( Filter filter: Filterable. class .getAnnotationsByType( Filter. class ) ) {
30 System.out.println( filter.value() );
31 }
32 }
33 }

我们可以看到，有一个注解类 Filter 被注解为@Repeatable（ Filters .class）。接口 Filters 只是一个用来持有注解 Filter 的“容器”，所以Java编译器力图对开发者们隐藏它。因此可以看到，在接口 Filterable 中声明了2次 Filter 注解（却并未提及接口 Filters ）。

此外，反射API提供了一个新方法 getAnnotationsByType() 用来返回特定类型的所有重复型注解（请注意， Filterable .class.getAnnotation（ Filters .class）将返回 Filters 的实例，这是由编译器自动注入实现的）。

该程序的输出如下：

1 filter1
2 filter2

更多详细信息请参考官方文档。

2.5. 更强大的类型推断

Java 8的编译器在类型推断上改进了很多。很多情况下，编译器可以自动推断出参数的类型，从而保持代码整洁。我们来看一个例子。

01 package com.javacodegeeks.java8.type.inference;
02
03 public class Value< T > {
04 public static < T > T defaultValue() {
05 return null ;
06 }
07
08 public T getOrDefault( T value, T defaultValue ) {
09 return ( value != null ) ? value : defaultValue;
10 }
11 }

下面是 Value<String> 类型的用法。

1 package com.javacodegeeks.java8.type.inference;
2
3 public class TypeInference {
4 public static void main(String[] args) {
5 final Value< String > value = new Value<>();
6 value.getOrDefault( "22" , Value.defaultValue() );
7 }
8 }

Value.defaultValue() 的参数类型可以被编译器推断得出而不需显式声明。在Java 7中，同样的代码编译不通过，需要更改为 Value<String> defaultValue() 。

2.6. 扩展的注解支持

Java 8扩展了注解的适用范围。从现在开始，绝大部分的东西都可以被注解：局部变量、泛型、超类、和接口实现，甚至可以是方法的异常声明。下面来看几个例子。

01 package com.javacodegeeks.java8.annotations;
02
03 import java.lang.annotation.ElementType;
04 import java.lang.annotation.Retention;
05 import java.lang.annotation.RetentionPolicy;
06 import java.lang.annotation.Target;
07 import java.util.ArrayList;
08 import java.util.Collection;
09
10 public class Annotations {
11 @Retention ( RetentionPolicy.RUNTIME )
12 @Target ( { ElementType.TYPE_USE, ElementType.TYPE_PARAMETER } )
13 public @interface NonEmpty {
14 }
15
16 public static class Holder< @NonEmpty T > extends @NonEmpty Object {
17 public void method() throws @NonEmpty Exception {
18 }
19 }
20
21 @SuppressWarnings ( "unused" )
22 public static void main(String[] args) {
23 final Holder< String > holder = new @NonEmpty Holder< String >();
24 @NonEmpty Collection< @NonEmpty String > strings = new ArrayList<>();
25 }
26 }

ElementType. TYPE_USE 和 ElementType. TYPE_PARAMETER 是两个新增加的元素类型，用来描述注解的适用场景。注解处理API（ Annotation Processing API ）也做了一些小的改动，以使之能够正确处理这些Java编程语言中新加入的的注解类型。

3. Java编译器的新特性

3.1. 参数名

很长时间以来，Java开发者们就一直在尝试各种办法，用来在Java字节码中保存方法的参数名，同时使得它在运行时可用（例如Paranamer库）。Java 8终于在其语言和字节码都加入了这个亟需的功能，前者通过反射API和方法 Parameter.getName() 实现，后者通过新的javac编译参数 -parameters 实现。

01 package com.javacodegeeks.java8.parameter.names;
02
03 import java.lang.reflect.Method;
04 import java.lang.reflect.Parameter;
05
06 public class ParameterNames {
07 public static void main(String[] args) throws Exception {
08 Method method = ParameterNames. class .getMethod( "main" , String[]. class );
09 for ( final Parameter parameter: method.getParameters() ) {
10 System.out.println( "Parameter: " + parameter.getName() );
11 }
12 }
13 }

如果你在编译这个类时没有使用参数 -parameters ，那么你的运行结果应该类似于：

1 Parameter: arg0

使用参数 -parameters 编译后的程序输出将会不同（参数的实际名称将会显示）：

1 Parameter: args

对于有经验的Maven使用者，参数 -parameters 可以通过更改 maven-compiler-plugin 中的配置添加到编译器中：

01 < plugin >
02 < groupId >org.apache.maven.plugins</ groupId >
03 < artifactId >maven-compiler-plugin</ artifactId >
04 < version >3.1</ version >
05 < configuration >
06 < compilerArgument >-parameters</ compilerArgument >
07 < source >1.8</ source >
08 < target >1.8</ target >
09 </ configuration >
10 </ plugin >

最新版的 Eclipse Kepler SR2 （请查看下载指南）能够支持Java 8，而且提供了编译参数设置项，参看下图。

图1 . 在Eclipse项目中设置支持Java 8的编译器参数 –parameters .

此外，类 Parameter 中有一个很便捷的方法 isNamePresent() 可以用来验证参数名称的可用性。

4. Java类库的新特性

Java 8新增了很多类，同时也扩展了很多已有的类，以更好的支持现代并发、函数式编程、日期/时间和其它操作。

4.1. Optional

著名的 NullPointerException 异常是迄今为止Java应用程序故障中最常见的原因。很久以前，伟大的Google Guava项目推出了 Optional ，作为 NullPointerException 的替代者；它不赞成在代码库中添加空值（null）检查造成代码污染，而是建议开发者们书写更整洁的代码。经过Google Guava的官方授权，如今 Optional 成为Java 8类库的一员。

Optional 只是一个容器：它可以是一个类型为 T 的 值 或者 空值 （null）。它提供了很多有用的方法，从而使得再也无需去显式检查空值（null）。请参考Java 8官方文档查看详细信息。

我们下面通过两个小例子了解一下 Optional 的用法：一个是空值，一个是非空值。

1 Optional< String > fullName = Optional.ofNullable( null );
2 System.out.println( "Full Name is set? " + fullName.isPresent() );
3 System.out.println( "Full Name: " + fullName.orElseGet( () -> "[none]" ) );
4 System.out.println( fullName.map( s -> "Hey " + s + "!" ).orElse( "Hey Stranger!" ) );

如果 Optional 的实例含有非空值的话，方法 isPresent() 返回 true ；反之返回 false 。方法 orElseGet() 提供了一种回退机制：它的实现是接受一个能够产生默认值的方法；从而可以防止 Optional 值为空。方法 map() 用来转换 Optional 的现有值并且返回一个新的 Optional 实例。方法 orElse() 与 orElseGet() 类似，所不同的是它能够接受默认值(而不是默认方法)。上面代码的运行结果如下：

1 Full Name is set? false
2 Full Name: [none]
3 Hey Stranger!

我们来简单看看另外一个例子：

1 Optional< String > firstName = Optional.of( "Tom" );
2 System.out.println( "First Name is set? " + firstName.isPresent() );
3 System.out.println( "First Name: " + firstName.orElseGet( () -> "[none]" ) );
4 System.out.println( firstName.map( s -> "Hey " + s + "!" ).orElse( "Hey Stranger!" ) );
5 System.out.println();

它的输出如下：

1 First Name is set? true
2 First Name: Tom
3 Hey Tom!

更多详细信息请参考官方文档。

4.2. Streams

新添加的Stream API（ java.util.stream ）为Java引入了现实世界中的函数式编程风格。这是迄今为止Java类库最全面的一次改进，旨在让Java开发人员可以编写有效、整洁、简洁的代码，从而显著提高其工作效率。

Stream API使得集合操作大为简化（我们后面会看到其实不仅仅限于Java集合类）。下面我们通过一个简单的Task类来看看具体用法。

01 public class Streams  {
02 private enum Status {
03 OPEN, CLOSED
04 };
05
06 private static final class Task {
07 private final Status status;
08 private final Integer points;
09
10 Task( final Status status, final Integer points ) {
11 this .status = status;
12 this .points = points;
13 }
14
15 public Integer getPoints() {
16 return points;
17 }
18
19 public Status getStatus() {
20 return status;
21 }
22
23 @Override
24 public String toString() {
25 return String.format( "[%s, %d]" , status, points );
26 }
27 }
28 }

Task类有一个属性-点数（一个虚拟的任务复杂度），状态可以是 OPEN 或 CLOSED 。我们首先创建一个小的Task集合。

1 final Collection< Task > tasks = Arrays.asList(
2 new Task( Status.OPEN, 5 ),
3 new Task( Status.OPEN, 13 ),
4 new Task( Status.CLOSED, 8 )
5 );

我们要解决的第一个问题是，所有状态为 OPEN 的任务一共有多少点数？在Java 8之前，通常的解决办法是通过 foreach 迭代来做某种排序。但在Java 8中，我们的答案是Stream：一个支持顺序和并行聚集操作的元素序列。

1 // Calculate total points of all active tasks using sum()
2 final long totalPointsOfOpenTasks = tasks
3 .stream()
4 .filter( task -> task.getStatus() == Status.OPEN )
5 .mapToInt( Task::getPoints )
6 .sum();
7
8 System.out.println( "Total points: " + totalPointsOfOpenTasks );

现在控制台输出如下：

1 Total points: 18

这里有几点需要说明一下。首先，Task集合转换成Stream的形式。然后，通过Stream的 filter 操作，过滤出所有状态为 CLOSED 的任务。下一步，通过调用每一个任务实例的 Task::getPoints 方法， mapToInt 操作可以把 Task Stream 转换为 Integer Stream 。最后，使用 sum 方法，计算出所有点数的总和，进而产生最终结果。

在继续看下一个例子之前，我们要牢记Stream的几点说明（更多详情）。Stream操作分为“中间操作”和“终端操作”。

“中间操作”会返回一个新的Stream。这些操作总是延迟执行的，当执行一个中间操作比如 filter 时，并不会真的执行任何过滤操作；而是创建一个新的Stream，当这个新的Stream被遍历时，它里面会包含原来Stream中与参数中指定的谓词（Predicate）匹配的那些元素。

“终端操作”，如 forEach 或者 sum ，则会遍历stream从而产生结果或者附带结果。在终端操作执行完毕后，Stream的管道会被视为已经消费完毕，不可再次使用。在大多数情况下，终端操作是“贪婪的”，总是能够即时完成数据的遍历操作。

Stream还有另一个变化是对它现在提供对并行处理的天然支持。我们来看一个例子，如何统计所有任务中的点数总和。

1 // Calculate total points of all tasks
2 final double totalPoints = tasks
3 .stream()
4 .parallel()
5 .map( task -> task.getPoints() ) // or map( Task::getPoints )
6 .reduce( 0 , Integer::sum );
7
8 System.out.println( "Total points (all tasks): " + totalPoints );

这个例子和我们之前提到的第一个例子非常类似，不过在这个例子中，我们尝试了并行处理所有task、通过reduce方法计算最终结果。控制台输出如下：

1 Total points (all tasks): 26.0

我们经常会有需要按照某些条件对集合元素进行分组。Stream可以实现这个需求，下面用一个例子演示一下。

1 // Group tasks by their status
2 final Map< Status, List< Task > > map = tasks
3 .stream()
4 .collect( Collectors.groupingBy( Task::getStatus ) );
5 System.out.println( map );

本例的控制台输出如下：

1 {CLOSED=[[CLOSED, 8 ]], OPEN=[[OPEN, 5 ], [OPEN, 13 ]]}

最后一个例子，我们来根据每个task的点数来计算一下在整个集合中，每个task所占的总体百分比（或比重）。

01 // Calculate the weight of each tasks (as percent of total points)
02 final Collection< String > result = tasks
03 .stream() // Stream< String >
04 .mapToInt( Task::getPoints ) // IntStream
05 .asLongStream() // LongStream
06 .mapToDouble( points -> points / totalPoints ) // DoubleStream
07 .boxed() // Stream< Double >
08 .mapToLong( weigth -> ( long )( weigth * 100 ) ) // LongStream
09 .mapToObj( percentage -> percentage + "%" ) // Stream< String>
10 .collect( Collectors.toList() ); // List< String >
11
12 System.out.println( result );

控制台输出如下：

1 [ 19 %, 50 %, 30 %]

最后，正如我们之前提到过的，Stream API不仅仅与Java集合类有关。典型的I/O操作，比如从文本文件中逐行读取文本内容，就能很好的从stream 处理中受益。这里有个小例子可以验证一下。

1 final Path path = new File( filename ).toPath();
2 try ( Stream< String > lines = Files.lines( path, StandardCharsets.UTF_8 ) ) {
3 lines.onClose( () -> System.out.println( "Done!" ) ).forEach( System.out::println );
4 }

调用Stream的 onClose ()方法，会返回一个等价的带有关闭句柄的流。这个关闭句柄在Stream的 close() 方法被调用时会执行。

Stream API和Lambda表达式，还有接口中默认方法和静态方法支持的方法引用，都是Java 8对现代软件开发中的编程范式的响应。更多详细信息请参考官方文档。

4.3. 日期/时间API (JSR 310)

Java 8引入了新的日期-时间API(JSR 310)，改进了日期和时间的操作管理。日期和时间操作曾经一度是让Java开发人员最感痛苦的问题，在 java.util.Date 之后引入的 java.util.Calendar 也丝毫没有改善这种状况（甚至可以说它使得日期时间操作更加令人费解）。

这就导致了Joda-Time的诞生：一个面向Java的日期/时间API的理想替代者。Java 8中新的日期-时间API(JSR 301) 深受Joda-Time的影响，可以说是尽取其精华。新的 java.time 包中包含了所有关于日期、时间、日期/时间、时区、Instant、Duration和时钟操作的类。设计这个API的时候已经着重考虑了原有方法的不可变性：不允许任何更改（来源于 java.util.Calendar 的前车之鉴）。如果必须改变的话，就会返回一个新的实例。

我们来看一看其中几个关键的类以及他们的用法。第一个是 Clock 类，它可以通过时区来获得当前Instant、日期和时间。 Clock 类可以用来替代 System.currentTimeMillis() 和 TimeZone.getDefault() 。

1 // Get the system clock as UTC offset
2 final Clock clock = Clock.systemUTC();
3 System.out.println( clock.instant() );
4 System.out.println( clock.millis() );

控制台的输出示例如下：

1 2014 - 04 -12T15: 19 : 29 .282Z
2 1397315969360

我们要看的另外两个类是 LocaleDate 和 LocaleTime 。 LocaleDate 只包含ISO-8601日历系统的中日期部分，不含时区信息；与此对应， LocaleTime 只包含ISO-8601日历系统中的时间部分，不含时区信息。 LocaleDate 和 LocaleTime 都可以通过 Clock 对象创建。

01 // Get the local date and local time
02 final LocalDate date = LocalDate.now();
03 final LocalDate dateFromClock = LocalDate.now( clock );
04
05 System.out.println( date );
06 System.out.println( dateFromClock );
07
08 // Get the local date and local time
09 final LocalTime time = LocalTime.now();
10 final LocalTime timeFromClock = LocalTime.now( clock );
11
12 System.out.println( time );
13 System.out.println( timeFromClock );

控制台上的输出示例如下：

1 2014 - 04 - 12
2 2014 - 04 - 12
3 11 : 25 : 54.568
4 15 : 25 : 54.568

LocalDateTime 类整合了 LocaleDate 和 LocaleTime ，它含有ISO-8601日历系统下中的日期和时间部分，但是不含时区信息。一个简单的例子如下所示。

1 // Get the local date/time
2 final LocalDateTime datetime = LocalDateTime.now();
3 final LocalDateTime datetimeFromClock = LocalDateTime.now( clock );
4
5 System.out.println( datetime );
6 System.out.println( datetimeFromClock );

控制台上的输出示例如下：

1 2014 - 04 -12T11: 37 : 52.309
2 2014 - 04 -12T15: 37 : 52.309

如果要获得特定时区的日期/时间，可以使用 ZonedDateTime 类。它包含ISO-8601日历系统 中的日期和时间，同时含有时区信息。这里有两个例子，可以看看不同时区的显示结果。

1 // Get the zoned date/time
2 final ZonedDateTime zonedDatetime = ZonedDateTime.now();
3 final ZonedDateTime zonedDatetimeFromClock = ZonedDateTime.now( clock );
4 final ZonedDateTime zonedDatetimeFromZone = ZonedDateTime.now( ZoneId.of( "America/Los_Angeles" ) );
5
6 System.out.println( zonedDatetime );
7 System.out.println( zonedDatetimeFromClock );
8 System.out.println( zonedDatetimeFromZone );

控制台上的输出示例：

1 2014 - 04 -12T11: 47 : 01.017 - 04 : 00 [America/New_York]
2 2014 - 04 -12T15: 47 : 01 .017Z
3 2014 - 04 -12T08: 47 : 01.017 - 07 : 00 [America/Los_Angeles]

最后，我们来看看 Duration 类：基于秒和纳秒的时间计数。使用它可以非常容易的计算两个日期间的差异。我们通过例子来具体看一下。

1 // Get duration between two dates
2 final LocalDateTime from = LocalDateTime.of( 2014 , Month.APRIL, 16 , 0 , 0 , 0 );
3 final LocalDateTime to = LocalDateTime.of( 2015 , Month.APRIL, 16 , 23 , 59 , 59 );
4
5 final Duration duration = Duration.between( from, to );
6 System.out.println( "Duration in days: " + duration.toDays() );
7 System.out.println( "Duration in hours: " + duration.toHours() );

上面这个例子计算了日期 2014年4月16日 和 2015年4月16日 之间的差异（以天计、以小时计）。控制台上的示例输出如下：

1 Duration in days: 365
2 Duration in hours: 8783

Java 8中新的日期/时间API给人的总体印象是非常积极的。其中一部分原因是因为它是建立在经历了实战考验的Joda-Time的基础之上；还有一部分原因是这一次它终于能够得到认真对待，而且听取了开发者们的声音。更多详细信息请参考官方文档。

4.4. Nashorn JavaScript引擎

Java 8引入了一个新的Nashorn JavaScript引擎，它允许在JVM上开发和运行特定类型的JavaScript应用。Nashorn JavaScript引擎仅仅是javx.script.ScriptEngine的另一种实现，并遵循相同的规则，允许Java和JavaScript互相操作。这里有一个小例子。

1 ScriptEngineManager manager = new ScriptEngineManager();
2 ScriptEngine engine = manager.getEngineByName( "JavaScript" );
3
4 System.out.println( engine.getClass().getName() );
5 System.out.println( "Result:" + engine.eval( "function f() { return 1; }; f() + 1;" ) );

控制台上的输出如下：

1 jdk.nashorn.api.scripting.NashornScriptEngine
2 Result: 2

我们在以后的文章《Java 8工具类详解》中会继续讨论Nashorn。

4.5. Base64

对Base64编码的支持最终在Java 8版本中成为Java标准库的一员。它非常的易于使用，下面的例子可以展示一二。

01 package com.javacodegeeks.java8.base64;
02
03 import java.nio.charset.StandardCharsets;
04 import java.util.Base64;
05
06 public class Base64s {
07 public static void main(String[] args) {
08 final String text = "Base64 finally in Java 8!" ;
09
10 final String encoded = Base64
11 .getEncoder()
12 .encodeToString( text.getBytes( StandardCharsets.UTF_8 ) );
13 System.out.println( encoded );
14
15 final String decoded = new String(
16 Base64.getDecoder().decode( encoded ),
17 StandardCharsets.UTF_8 );
18 System.out.println( decoded );
19 }
20 }

程序运行后，在控制台输出中能够同时看到编码和解码的字符串：

1 QmFzZTY0IGZpbmFsbHkgaW4gSmF2YSA4IQ==
2 Base64 finally in Java 8 !

Base64类同时也提供了面向URL和MIME的编码/解码（ Base64. getUrlEncoder() / Base64. getUrlDecoder() ， Base64. getMimeEncoder() / Base64. getMimeDecoder() ）。

4.6. 并行数组

Java 8中增加了很多新的方法来支持并行数组处理。可以说，其中最重要的就是 parallelSort() ，它可以显著加快在多核处理器上的排序操作。我们用下面的小例子来实际演示一下这个新的方法家族（ parallelXxx ）。

01 package com.javacodegeeks.java8.parallel.arrays;
02
03 import java.util.Arrays;
04 import java.util.concurrent.ThreadLocalRandom;
05
06 public class ParallelArrays {
07 public static void main( String[] args ) {
08 long [] arrayOfLong = new long [ 20000 ];
09
10 Arrays.parallelSetAll( arrayOfLong,
11 index -> ThreadLocalRandom.current().nextInt( 1000000 ) );
12 Arrays.stream( arrayOfLong ).limit( 10 ).forEach(
13 i -> System.out.print( i + " " ) );
14 System.out.println();
15
16 Arrays.parallelSort( arrayOfLong );
17 Arrays.stream( arrayOfLong ).limit( 10 ).forEach(
18 i -> System.out.print( i + " " ) );
19 System.out.println();
20 }
21 }

这一小段代码使用了方法 parallelSetAll() 来生成一个含有20000个随机数的数组。然后，调用方法 parallelSort() 进行排序。该程序分别输出了排序前和排序后的前10个元素，以验证这个数组确实是已经被排序了。程序的示例输出如下（请注意所有的数组元素都是随机生成的）：

1 Unsorted: 591217 891976 443951 424479 766825 351964 242997 642839 119108 552378
2 Sorted: 39 220 263 268 325 607 655 678 723 793

4.7. 并发

类 java.util.concurrent.ConcurrentHashMap 中加入了一些新的方法来支持聚集操作。这些聚集操作基于新增加的stream功能和lambda表达式。此外，类 java.util.concurrent.ForkJoinPoolclass 也新增了一些方法，用来支持公共池（Common Pool，可以查看我们的Java并发免费课程）。

新加入的 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引擎。它接受JavaScript源代码文件的列表作为参数，并一一运行它们。例如，我们创建一个含有如下内容的文件 func.js ：

1 function f() {
2 return 1 ;
3 };
4
5 print( f() + 1 );

从命令行运行这个文件时，我们需要把它作为参数传递给 jjs：

1 jjs func.js

控制台的输出结果如下：

1 2

更多详细信息请参考官方文档。

5.2. 类的依赖关系分析：jdeps

jdeps 确实可说是一个非常好用的命令行工具。它可以显示Java类文件的包级或类级的依赖关系。它的合法输入包括：类文件、目录、或 JAR 文件。默认情况下， jdeps 会把分析结果输出到系统标准输出（控制台）。

下面我们以流行的Spring Framework为例，来看一下依赖关系报告。简单起见，我们只分析其中一个JAR文件： org.springframework.core-3.0.5.RELEASE.jar 。

1 jdeps org.springframework.core- 3.0 . 5 .RELEASE.jar

这个命令会输出很多内容，所以我们只看其中一部分。在结果中依赖关系是按包分组显示的。如果在classpath中找不到任何依赖，会显示“ 未找到 ”(not found)。

01 org.springframework.core- 3.0 . 5 .RELEASE.jar -> C:Program FilesJavajdk1. 8 .0jrelibrt.jar
02 org.springframework.core (org.springframework.core- 3.0 . 5 .RELEASE.jar)
03 -> java.io
04 -> java.lang
05 -> java.lang.annotation
06 -> java.lang.ref
07 -> java.lang.reflect
08 -> java.util
09 -> java.util.concurrent
10 -> org.apache.commons.logging                         not found
11 -> org.springframework.asm                            not found
12 -> org.springframework.asm.commons                    not found
13 org.springframework.core.annotation (org.springframework.core- 3.0 . 5 .RELEASE.jar)
14 -> java.lang
15 -> java.lang.annotation
16 -> java.lang.reflect
17 -> java.util

更多详细信息请参考官方文档。

6. Java运行时 (JVM)的新特性

JVM移除了 PermGen 空间，取而代之的是Metaspace（JEP 122）。相应的，JVM参数 -XX ： PermSize 和 -XX ： MaxPermSize 已被替换为 -XX ： MetaSpaceSize 和 -XX ： MaxMetaspaceSize 。

7. 结语

未来就在这里：Java 8提供了这些新特性以使开发者们更加高效工作，从而推动这个伟大的平台向前发展。虽然现在就将生产系统迁移至Java 8平台还为时尚早，但是在未来几个月，它的采用率应该会逐渐增多。不管怎样，现在可以开始准备你的代码库，使之能与Java 8兼容，并准备好随时切换至Java 8；一旦Java 8被证实是足够安全和稳定的，就可以立即开始迁移。

作为社区对Java 8的认可和支持，Pivotal最近发布了Spring Framework 4.0.3，完全支持符合生产环境要求的Java 8平台开发。

如果你喜欢这篇文章，请订阅我们的 newsletter 来享受每周一次的更新推送和免费技术白皮书！此外，请访问 JCG学院 查看更多高级培训课程！

非常欢迎你们能够为这么多令人振奋的Java 8新特性提供意见和建议！

8. 相关资源

这里还有更多资源更加深入的讨论了Java 8的不同特性：

  • What’s New in JDK 8: http://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html
  • The Java Tutorials: http://docs.oracle.com/javase/tutorial/
  • WildFly 8, JDK 8, NetBeans 8, Java EE 7: http://blog.arungupta.me/2014/03/wildfly8-jdk8-netbeans8-javaee7-excellent-combo-enterprise-java/
  • Java 8 Tutorial: http://winterbe.com/posts/2014/03/16/java-8-tutorial/
  • JDK 8 Command-line Static Dependency Checker: http://marxsoftware.blogspot.ca/2014/03/jdeps.html
  • The Illuminating Javadoc of JDK 8: http://marxsoftware.blogspot.ca/2014/03/illuminating-javadoc-of-jdk-8.html
  • The Dark Side of Java 8: http://blog.jooq.org/2014/04/04/java-8-friday-the-dark-side-of-java-8/
  • Installing Java™ 8 Support in Eclipse Kepler SR2: http://www.eclipse.org/downloads/java8/
  • Java 8: http://www.baeldung.com/java8
  • Oracle Nashorn. A Next-Generation JavaScript Engine for the JVM: http://www.oracle.com/technetwork/articles/java/jf14-nashorn-2126515.html

相关阅读

目录[+]