Question

编者注：Java 8 已经公布有一段时间了，种种迹象表明 Java 8 是一个有重大改变的发行版。

在 Java Code Geeks 上已经有大量的关于 Java 8 的教程了，像 玩转 Java 8——lambda 与并发 ， Java 8 Date Time API 教程： LocalDateTime 和 在 Java 8 中抽象类与接口的比较 。

我们也在其他地方引用了 15 个必读的 Java 8 教程 。当然，我们也探究了 Java 8 的一些不足之处，比如 Java 8 的“黑暗面” 。

现在，是时候把所有 Java 8 的重要特性收集整理成一篇单独的文章了，希望这篇文章能给你带来阅读上的乐趣。开始吧！

目录结构

1. 介绍
2. Java 语言的新特性

   2.1 Lambdas 表达式与 Functional 接口

   2.2 接口的默认与静态方法

   2.3 方法引用

   2.4 重复注解

   2.5 更好的类型推测机制

   2.6 扩展注解的支持

3. Java 编译器的新特性

   3.1 参数名字

4. Java 类库的新特性

   4.1 Optional

   4.2 Streams

   4.3 Date/Time API (JSR 310)

   4.4 JavaScript 引擎 Nashorn

   4.5 Base64

   4.6 并行（parallel）数组

   4.7 并发（Concurrency）

5. 新增的 Java 工具

   5.1 Nashorn 引擎: jjs

   5.2 类依赖分析器: jdeps

6. Java 虚拟机（JVM）的新特性
7. 总结
8. 更多资源

1.介绍

毫无疑问， Java 8 发行版 是自 Java 5（发行于 2004，已经过了相当一段时间了）以来最具革命性的版本。Java 8 为 Java 语言、编译器、类库、开发工具与 JVM（Java 虚拟机）带来了大量新特性。在这篇教程中，我们将一一探索这些变化，并用真实的例子说明它们适用的场景。

这篇教程由以下几部分组成，它们分别涉及到 Java 平台某一特定方面的内容：

• Java 语言
• 编译器
• 类库
• 工具
• Java 运行时（JVM）

2.Java 语言的新特性

不管怎么说，Java 8 都是一个变化巨大的版本。你可能认为 Java 8 耗费了大量的时间才得以完成是为了实现了每个 Java 程序员所期待的特性。在这个小节里，我们将会涉及到这些特性的大部分。

2.1 Lambda 表达式与 Functional 接口

Lambda 表达式（也称为闭包）是整个 Java 8 发行版中最受期待的在 Java 语言层面上的改变，Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中），或者把代码看成数据：函数式程序员对这一概念非常熟悉。在 JVM 平台上的很多语言（Groovy， Scala ，……）从一开始就有 Lambda，但是 Java 程序员不得不使用毫无新意的匿名类来代替 lambda。

关于 Lambda 设计的讨论占用了大量的时间与社区的努力。可喜的是，最终找到了一个平衡点，使得可以使用一种即简洁又紧凑的新方式来构造 Lambdas。在最简单的形式中，一个 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 的话，它们会被隐含的转为 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 表达式。java.lang.Runnable 与 java.util.concurrent.Callable 是函数式接口最典型的两个例子。在实际使用过程中，函数式接口是容易出错的：如有某个人在接口定义中增加了另一个方法，这时，这个接口就不再是函数式的了，并且编译过程也会失败。为了克服函数式接口的这种脆弱性并且能够明确声明接口作为函数式接口的意图，Java 8 增加了一种特殊的注解 @FunctionalInterface（Java 8 中所有类库的已有接口都添加了 @FunctionalInterface 注解）。让我们看一下这种函数式接口的定义：

@FunctionalInterface
public interface Functional {
    void method();
}

需要记住的一件事是： 默认方法与静态方法 并不影响函数式接口的契约，可以任意使用：

@FunctionalInterface
public interface FunctionalDefaultMethods {
    void method();

    default void defaultMethod() {            
    }        
}

Lambda 是 Java 8 最大的卖点。它具有吸引越来越多程序员到 Java 平台上的潜力，并且能够在纯 Java 语言环境中提供一种优雅的方式来支持函数式编程。更多详情可以参考 官方文档 。

2.2 接口的默认方法与静态方法

Java 8 用默认方法与静态方法这两个新概念来扩展接口的声明。 默认方法 使接口有点像 Traits（Scala 中特征(trait) 类似于 Java 中的 Interface，但它可以包含实现代码，也就是目前 Java8 新增的功能），但与传统的接口又有些不一样，它允许在已有的接口中添加新方法，而同时又保持了与旧版本代码的兼容性。

默认方法与抽象方法不同之处在于抽象方法必须要求实现，但是默认方法则没有这个要求。相反，每个接口都必须提供一个所谓的默认实现，这样所有的接口实现者将会默认继承它（如果有必要的话，可以覆盖这个默认实现）。让我们看看下面的例子：

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()，Defaulable 接口的实现者之一 DefaultableImpl 实现了这个接口，并且让默认方法保持原样。Defaulable 接口的另一个实现者 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 接口，而同时能够保障正常的编译过程。这方面好的例子是大量的方法被添加到 java.util.Collection 接口中去：stream()，parallelStream()，forEach()，removeIf()，……

尽管默认方法非常强大，但是在使用默认方法时我们需要小心注意一个地方：在声明一个默认方法前，请仔细思考是不是真的有必要使用默认方法，因为默认方法会带给程序歧义，并且在复杂的继承体系中容易产生编译错误。更多详情请参考 官方文档

2.3 方法引用

方法引用提供了非常有用的语法，可以直接引用已有 Java 类或对象（实例）的方法或构造器。与 lambda 联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。

下面，我们以定义了 4 个方法的 Car 这个类作为例子，区分 Java 中支持的 4 种不同的方法引用。

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 );

运行上面的 Java 程序在控制台上会有下面的输出（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 打破了这条规则，引入了重复注解机制，这样相同的注解可以在同一地方声明多次。

重复注解机制本身必须用 @Repeatable 注解。事实上，这并不是语言层面上的改变，更多的是编译器的技巧，底层的原理保持不变。让我们看一个快速入门的例子：

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() );
        }
    }
}

正如我们看到的，这里有个使用 @Repeatable( Filters.class ) 注解的注解类 Filter，Filters 仅仅是 Filter 注解的数组，但 Java 编译器并不想让程序员意识到 Filters 的存在。这样，接口 Filterable 就拥有了两次 Filter（并没有提到 Filter）注解。

同时，反射相关的 API 提供了新的函数 getAnnotationsByType() 来返回重复注解的类型（请注意 Filterable.class.getAnnotation( Filters.class ) 经编译器处理后将会返回 Filters 的实例）。

程序输出结果如下：

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_USE 和 ElementType.TYPE_PARAMETER 是两个新添加的用于描述适当的注解上下文的元素类型。在 Java 语言中，注解处理 API 也有小的改动来识别新增的类型注解。

3. Java 编译器的新特性

3.1 参数名字

很长一段时间里，Java 程序员一直在发明不同的方式使得 方法参数的名字能保留在 Java 字节码 中，并且能够在运行时获取它们（比如， Paranamer 类库 ）。最终，在 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() );
        }
    }
}

如果不使用–parameters 参数来编译这个类，然后运行这个类，会得到下面的输出：

Parameter: arg0

如果使用–parameters 参数来编译这个类，程序的结构会有所不同（参数的真实名字将会显示出来）：

Parameter: args

对于 有经验的 Maven 用户 ，通过 maven-compiler-plugin 的配置可以将-parameters 参数添加到编译器中去。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    maven-compiler-plugin
    <version>3.1</version>
    <configuration>
        <compilerArgument>-parameters</compilerArgument>
        <source>1.8</source>
        <target>1.8</target>
    </configuration>
</plugin>

针对 Java 8 最新发布的 Eclipse Kepler SR2（请检查这里的 下载说明 ）提供了非常实用的配置选项，可以通过下图的配置方式来控制编译器行为

图 1. 配置 Eclipse 工程使之支持 Java 8 编译器的新特性——parameters 参数

此外，Parameter 类有一个很方便的方法 isNamePresent() 来验证是否可以获取参数的名字。

4. Java 类库的新特性

Java 8 通过增加大量新类，扩展已有类的功能的方式来改善对并发编程、函数式编程、日期/时间相关操作以及其他更多方面的支持。

4.1 Optional

到目前为止， 臭名昭著的空指针异常 是导致 Java 应用程序失败的最常见原因。以前，为了解决空指针异常， Google 公司著名的 Guava 项目 引入了 Optional 类，Guava 通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到 Google Guava 的启发，Optional 类已经成为 Java 8 类库的一部分。

Optional 实际上是个容器：它可以保存类型 T 的值，或者仅仅保存 null。Optional 提供很多有用的方法，这样我们就不用显式进行空值检测。更多详情请参考 官方文档 。

我们下面用两个小例子来演示如何使用 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。为了防止 Optional 为空值，orElseGet() 方法通过回调函数来产生一个默认值。map() 函数对当前 Optional 的值进行转化，然后返回一个新的 Optional 实例。orElse() 方法和 orElseGet() 方法类似，但是 orElse 接受一个默认值而不是一个回调函数。下面是这个程序的输出：

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 Stream

最新添加的 Stream API （java.util.stream） 把真正的函数式编程风格引入到 Java 中。这是目前为止对 Java 类库最好的补充，因为 Stream API 可以极大提供 Java 程序员的生产力，让程序员写出高效率、干净、简洁的代码。

Stream 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 )
);

我们下面要讨论的第一个问题是所有状态为 OPEN 的任务一共有多少分数？在 Java 8 以前，一般的解决方式用 foreach 循环，但是在 Java 8 里面我们可以使用 stream：一串支持连续、并行聚集操作的元素。

// 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

这里有几个注意事项。第一，task 集合被转换化为其相应的 stream 表示。然后，filter 操作过滤掉状态为 CLOSED 的 task。下一步，mapToInt 操作通过 Task::getPoints 这种方式调用每个 task 实例的 getPoints 方法把 Task 的 stream 转化为 Integer 的 stream。最后，用 sum 函数把所有的分数加起来，得到最终的结果。

在继续讲解下面的例子之前，关于 stream 有一些需要注意的地方（详情 在这里 ）.stream 操作被分成了中间操作与最终操作这两种。

中间操作返回一个新的 stream 对象。中间操作总是采用惰性求值方式，运行一个像 filter 这样的中间操作实际上没有进行任何过滤，相反它在遍历元素时会产生了一个新的 stream 对象，这个新的 stream 对象包含原始 stream 中符合给定谓词的所有元素。

像 forEach、sum 这样的最终操作可能直接遍历 stream，产生一个结果或副作用。当最终操作执行结束之后，stream 管道被认为已经被消耗了，没有可能再被使用了。在大多数情况下，最终操作都是采用及早求值方式，及早完成底层数据源的遍历。

stream 另一个有价值的地方是能够原生支持并行处理。让我们来看看这个算 task 分数和的例子。

// 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 );

这个例子和第一个例子很相似，但这个例子的不同之处在于这个程序是并行运行的，其次使用 reduce 方法来算最终的结果。 下面是这个例子在控制台的输出：

Total points (all tasks): 26.0

经常会有这个一个需求：我们需要按照某种准则来对集合中的元素进行分组。Stream 也可以处理这样的需求，下面是一个例子：

// 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]]}

让我们来计算整个集合中每个 task 分数（或权重）的平均值来结束 task 的例子。

// 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%]

最后，就像前面提到的，Stream API 不仅仅处理 Java 集合框架。像从文本文件中逐行读取数据这样典型的 I/O 操作也很适合用 Stream API 来处理。下面用一个例子来应证这一点。

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 新的 Date-Time API (JSR 310) 在很大程度上受到 Joda-Time 的影响，并且吸取了其精髓。新的 java.time 包涵盖了 所有处理日期，时间，日期/时间，时区，时刻（instants），过程（during）与时钟（clock）的操作 。在设计新版 API 时，十分注重与旧版 API 的兼容性：不允许有任何的改变（从 java.util.Calendar 中得到的深刻教训）。如果需要修改，会返回这个类的一个新实例。

让我们用例子来看一下新版 API 主要类的使用方法。第一个是 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

我们需要关注的其他类是 LocaleDate 与 LocalTime。LocaleDate 只持有 ISO-8601 格式且无时区信息的日期部分。相应的，LocaleTime 只持有 ISO-8601 格式且无时区信息的时间部分。LocaleDate 与 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

LocaleDateTime 把 LocaleDate 与 LocaleTime 的功能合并起来，它持有的是 ISO-8601 格式无时区信息的日期与时间。下面是一个 快速入门 的例子。

// 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

如果你需要特定时区的日期/时间，那么 ZonedDateTime 是你的选择。它持有 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 类：在秒与纳秒级别上的一段时间。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 号与 2014 年 4 月 16 号之间的过程。下面是程序在控制台上的输出：

Duration in days: 365
Duration in hours: 8783

对 Java 8 在日期/时间 API 的改进整体印象是非常非常好的。一部分原因是因为它建立在“久战杀场”的 Joda-Time 基础上，另一方面是因为用来大量的时间来设计它，并且这次程序员的声音得到了认可。更多详情请参考 官方文档 。

4.4 JavaScript 引擎 Nashorn

Nashorn，一个新的 JavaScript 引擎随着 Java 8 一起公诸于世，它允许在 JVM 上开发运行某些 JavaScript 应用。Nashorn 就是 javax.script.ScriptEngine 的另一种实现，并且它们俩遵循相同的规则，允许 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

我们在后面的 Java 新工具 章节会再次谈到 Nashorn。

4.5 Base64

在 Java 8 中， Base64 编码 已经成为 Java 类库的标准。它的使用十分简单，下面让我们看一个例子：

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!

Base64 类同时还提供了对 URL、MIME 友好的编码器与解码器（Base64.getUrlEncoder() / Base64.getUrlDecoder(), Base64.getMimeEncoder() / Base64.getMimeDecoder()）。

4.6 并行（parallel）数组

Java 8 增加了大量的新方法来对数组进行并行处理。可以说，最重要的是 parallelSort() 方法，因为它可以在多核机器上极大提高数组排序的速度。下面的例子展示了新方法（parallelXxx）的使用。

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 并发（Concurrency）

在新增 Stream 机制与 lambda 的基础之上，在 java.util.concurrent.ConcurrentHashMap 中加入了一些新方法来支持聚集操作。同时也在 java.util.concurrent.ForkJoinPool 类中加入了一些新方法来支持共有资源池（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 文件：

function f() {
     return 1;
};

print( f() + 1 );

我们可以把这个文件作为参数传递给 jjs 使得这个文件可以在命令行中执行：

jjs func.js

下面是程序在控制台上的输出：

2

更多详情请参考 官方文档

5.2 类依赖分析器 jdeps

jdeps 是一个很有用的命令行工具。它可以显示 Java 类的包级别或类级别的依赖。它接受一个.class 文件，一个目录，或者一个 jar 文件作为输入。jdeps 默认把结果输出到系统输出（控制台）上。

下面我们查看现阶段较流行的 Spring 框架 类库的依赖报告，为了简化这个例子，我们只分析一个 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. Java 虚拟机（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 发布了 可在生产环境下支持 Java 8 的 Spring Framework 4.0.3 。

如果你喜欢这篇文章，请 订阅我们的邮件列表 来查看每周的更新以及免费赠送的白皮书。对于更高级的教程，请查看我们的[JCG 学院][ JCG ]。

我们欢迎你对 Java 8 中激动人心的特性进行评论！

8. 更多资源

下面一些文章从不同层面上深度讨论了 Java 8 的特性：

• JDK 8 新特性
• Java 教程
• WildFly 8, JDK 8, NetBeans 8, Java EE 7
• Java 8 教程
• JDK 8 命令行工具——静态依赖分析器
• 探究 JDK 8 的 Javadoc
• Java 8 的“黑暗面”
• 在 Eclipse Kepler SR2 添加 Java 8 支持
• Java 8
• Oracle Nashorn——JVM 平台上的下一代 JavaScript 引擎