java- Java 8的新特性

简介: 前言: Java 8 已经发布很久了,很多报道表明Java 8 是一次重大的版本升级。在Java Code Geeks上已经有很多介绍Java 8新特性的文章,例如Playing with Java 8 – Lambdas and Concurrency、Java 8 Date Time API Tutorial : LocalDateTime和Abstract Class Versus Interface in the JDK 8 Era。

前言: Java 8 已经发布很久了,很多报道表明Java 8 是一次重大的版本升级。在Java Code Geeks上已经有很多介绍Java 8新特性的文章,例如Playing with Java 8 – Lambdas and ConcurrencyJava 8 Date Time API Tutorial : LocalDateTimeAbstract Class Versus Interface in the JDK 8 Era。本文还参考了一些其他资料,例如:15 Must Read Java 8 TutorialsThe Dark Side of Java 8。本文综合了上述资料,整理成一份关于Java 8新特性的参考教材,希望你有所收获。

1. 简介

毫无疑问,Java 8是Java自Java 5(发布于2004年)之后的最重要的版本。这个版本包含语言、编译器、库、工具和JVM等方面的十多个新特性。在本文中我们将学习这些新特性,并用实际的例子说明在什么场景下适合使用。

这个教程包含Java开发者经常面对的几类问题:

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

2. Java语言的新特性

Java 8是Java的一个重大版本,有人认为,虽然这些新特性领Java开发人员十分期待,但同时也需要花不少精力去学习。在这一小节中,我们将介绍Java 8的大部分新特性。

2.1 Lambda表达式和函数式接口

Lambda表达式(也称为闭包)是Java 8中最大和最令人期待的语言改变。它允许我们将函数当成参数传递给某个方法,或者把代码本身当作数据处理:函数式开发者非常熟悉这些概念。很多JVM平台上的语言(Groovy、Scala等)从诞生之日就支持Lambda表达式,但是Java开发者没有选择,只能使用匿名内部类代替Lambda表达式。

Lambda的设计耗费了很多时间和很大的社区力量,最终找到一种折中的实现方案,可以实现简洁而紧凑的语言结构。最简单的Lambda表达式可由逗号分隔的参数列表、->符号和语句块组成,例如:

<code class="cs">Arrays.asList( <span class="hljs-string" style="color: rgb(0, 136, 0);">"a"</span>, <span class="hljs-string" style="color: rgb(0, 136, 0);">"b"</span>, <span class="hljs-string" style="color: rgb(0, 136, 0);">"d"</span> ).forEach( e -> System.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">out</span>.println( e ) );</code>

在上面这个代码中的参数e的类型是由编译器推理得出的,你也可以显式指定该参数的类型,例如:

<code class="coffeescript">Arrays.asList( <span class="hljs-string" style="color: rgb(0, 136, 0);">"a"</span>, <span class="hljs-string" style="color: rgb(0, 136, 0);">"b"</span>, <span class="hljs-string" style="color: rgb(0, 136, 0);">"d"</span> ).forEach( <span class="hljs-function"><span class="hljs-params" style="color: rgb(102, 0, 102);">( String e )</span> -></span> System.out.println( e ) );</code>

如果Lambda表达式需要更复杂的语句块,则可以使用花括号将该语句块括起来,类似于Java中的函数体,例如:

<code class="php">Arrays.asList( <span class="hljs-string" style="color: rgb(0, 136, 0);">"a"</span>, <span class="hljs-string" style="color: rgb(0, 136, 0);">"b"</span>, <span class="hljs-string" style="color: rgb(0, 136, 0);">"d"</span> ).<span class="hljs-keyword" style="color: rgb(0, 0, 136);">forEach</span>( e -> {
    System.out.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">print</span>( e );
    System.out.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">print</span>( e );
} );</code>

Lambda表达式可以引用类成员和局部变量(会将这些变量隐式得转换成final的),例如下列两个代码块的效果完全相同:

<code class="coffeescript">String separator = <span class="hljs-string" style="color: rgb(0, 136, 0);">","</span>;
Arrays.asList( <span class="hljs-string" style="color: rgb(0, 136, 0);">"a"</span>, <span class="hljs-string" style="color: rgb(0, 136, 0);">"b"</span>, <span class="hljs-string" style="color: rgb(0, 136, 0);">"d"</span> ).forEach( 
    <span class="hljs-function"><span class="hljs-params" style="color: rgb(102, 0, 102);">( String e )</span> -></span> System.out.<span class="hljs-built_in" style="color: rgb(102, 0, 102);">print</span>( e + separator ) );</code>

<code class="coffeescript">final String separator = <span class="hljs-string" style="color: rgb(0, 136, 0);">","</span>;
Arrays.asList( <span class="hljs-string" style="color: rgb(0, 136, 0);">"a"</span>, <span class="hljs-string" style="color: rgb(0, 136, 0);">"b"</span>, <span class="hljs-string" style="color: rgb(0, 136, 0);">"d"</span> ).forEach( 
    <span class="hljs-function"><span class="hljs-params" style="color: rgb(102, 0, 102);">( String e )</span> -></span> System.out.<span class="hljs-built_in" style="color: rgb(102, 0, 102);">print</span>( e + separator ) );</code>

Lambda表达式有返回值,返回值的类型也由编译器推理得出。如果Lambda表达式中的语句块只有一行,则可以不用使用return语句,下列两个代码片段效果相同:

<code class="coffeescript">Arrays.asList( <span class="hljs-string" style="color: rgb(0, 136, 0);">"a"</span>, <span class="hljs-string" style="color: rgb(0, 136, 0);">"b"</span>, <span class="hljs-string" style="color: rgb(0, 136, 0);">"d"</span> ).sort( <span class="hljs-function"><span class="hljs-params" style="color: rgb(102, 0, 102);">( e1, e2 )</span> -></span> e1.compareTo( e2 ) );</code>

<code class="coffeescript">Arrays.asList( <span class="hljs-string" style="color: rgb(0, 136, 0);">"a"</span>, <span class="hljs-string" style="color: rgb(0, 136, 0);">"b"</span>, <span class="hljs-string" style="color: rgb(0, 136, 0);">"d"</span> ).sort( <span class="hljs-function"><span class="hljs-params" style="color: rgb(102, 0, 102);">( e1, e2 )</span> -></span> {
    int result = e1.compareTo( e2 );
    <span class="hljs-keyword" style="color: rgb(0, 0, 136);">return</span> result;
} );</code>

Lambda的设计者们为了让现有的功能与Lambda表达式良好兼容,考虑了很多方法,于是产生了函数接口这个概念。函数接口指的是只有一个函数的接口,这样的接口可以隐式转换为Lambda表达式。java.lang.Runnablejava.util.concurrent.Callable是函数式接口的最佳例子。在实践中,函数式接口非常脆弱:只要某个开发者在该接口中添加一个函数,则该接口就不再是函数式接口进而导致编译失败。为了克服这种代码层面的脆弱性,并显式说明某个接口是函数式接口,Java 8 提供了一个特殊的注解@FunctionalInterface(Java 库中的所有相关接口都已经带有这个注解了),举个简单的函数式接口的定义:

<code class="java"><span class="hljs-annotation" style="color: rgb(155, 133, 157);">@FunctionalInterface</span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-class"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">interface</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">Functional</span> </span>{
    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">void</span> <span class="hljs-title">method</span><span class="hljs-params" style="color: rgb(102, 0, 102);">()</span></span>;
}</code>

不过有一点需要注意,默认方法和静态方法不会破坏函数式接口的定义,因此如下的代码是合法的。

<code class="java"><span class="hljs-annotation" style="color: rgb(155, 133, 157);">@FunctionalInterface</span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-class"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">interface</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">FunctionalDefaultMethods</span> </span>{
    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">void</span> <span class="hljs-title">method</span><span class="hljs-params" style="color: rgb(102, 0, 102);">()</span></span>;

    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">default</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">void</span> <span class="hljs-title">defaultMethod</span><span class="hljs-params" style="color: rgb(102, 0, 102);">()</span> </span>{            
    }        
}</code>

Lambda表达式作为Java 8的最大卖点,它有潜力吸引更多的开发者加入到JVM平台,并在纯Java编程中使用函数式编程的概念。如果你需要了解更多Lambda表达式的细节,可以参考官方文档

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

Java 8使用两个新概念扩展了接口的含义:默认方法和静态方法。默认方法使得接口有点类似traits,不过要实现的目标不一样。默认方法使得开发者可以在 不破坏二进制兼容性的前提下,往现存接口中添加新的方法,即不强制那些实现了该接口的类也同时实现这个新加的方法。

默认方法和抽象方法之间的区别在于抽象方法需要实现,而默认方法不需要。接口提供的默认方法会被接口的实现类继承或者覆写,例子代码如下:

<code class="java"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">private</span> <span class="hljs-class"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">interface</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">Defaulable</span> </span>{
    <span class="hljs-comment" style="color: rgb(136, 0, 0);">// Interfaces now allow default methods, the implementer may or </span>
    <span class="hljs-comment" style="color: rgb(136, 0, 0);">// may not implement (override) them.</span>
    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">default</span> String <span class="hljs-title">notRequired</span><span class="hljs-params" style="color: rgb(102, 0, 102);">()</span> </span>{ 
        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">return</span> <span class="hljs-string" style="color: rgb(0, 136, 0);">"Default implementation"</span>; 
    }        
}

<span class="hljs-keyword" style="color: rgb(0, 0, 136);">private</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span> <span class="hljs-class"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">class</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">DefaultableImpl</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">implements</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">Defaulable</span> </span>{
}

<span class="hljs-keyword" style="color: rgb(0, 0, 136);">private</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span> <span class="hljs-class"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">class</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">OverridableImpl</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">implements</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">Defaulable</span> </span>{
    <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@Override</span>
    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> String <span class="hljs-title">notRequired</span><span class="hljs-params" style="color: rgb(102, 0, 102);">()</span> </span>{
        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">return</span> <span class="hljs-string" style="color: rgb(0, 136, 0);">"Overridden implementation"</span>;
    }
}</code>

Defaulable接口使用关键字default定义了一个默认方法notRequired()DefaultableImpl类实现了这个接口,同时默认继承了这个接口中的默认方法;OverridableImpl类也实现了这个接口,但覆写了该接口的默认方法,并提供了一个不同的实现。

Java 8带来的另一个有趣的特性是在接口中可以定义静态方法,例子代码如下:

<code class="cs"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">private</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">interface</span> <span class="hljs-title">DefaulableFactory</span> {
    <span class="hljs-comment" style="color: rgb(136, 0, 0);">// Interfaces now allow static methods</span>
    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span> Defaulable <span class="hljs-title">create</span>(<span class="hljs-params" style="color: rgb(102, 0, 102);"> Supplier< Defaulable > supplier </span>) </span>{
        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">return</span> supplier.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">get</span>();
    }
}</code>

下面的代码片段整合了默认方法和静态方法的使用场景:

<code class="cpp"><span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">void</span> <span class="hljs-title">main</span><span class="hljs-params" style="color: rgb(102, 0, 102);">( String[] args )</span> </span>{
    Defaulable defaulable = DefaulableFactory.create( DefaultableImpl::<span class="hljs-keyword" style="color: rgb(0, 0, 136);">new</span> );
    System.out.println( defaulable.notRequired() );

    defaulable = DefaulableFactory.create( OverridableImpl::<span class="hljs-keyword" style="color: rgb(0, 0, 136);">new</span> );
    System.out.println( defaulable.notRequired() );
}</code>

这段代码的输出结果如下:

<code class="php"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">Default</span> implementation
Overridden implementation</code>

由于JVM上的默认方法的实现在字节码层面提供了支持,因此效率非常高。默认方法允许在不打破现有继承体系的基础上改进接口。该特性在官方库中的应用是:给java.util.Collection接口添加新方法,如stream()parallelStream()forEach()removeIf()等等。

尽管默认方法有这么多好处,但在实际开发中应该谨慎使用:在复杂的继承体系中,默认方法可能引起歧义和编译错误。如果你想了解更多细节,可以参考官方文档

2.3 方法引用

方法引用使得开发者可以直接引用现存的方法、Java类的构造方法或者实例对象。方法引用和Lambda表达式配合使用,使得java类的构造方法看起来紧凑而简洁,没有很多复杂的模板代码。

西门的例子中,Car类是不同方法引用的例子,可以帮助读者区分四种类型的方法引用。

<code class="cs"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">class</span> <span class="hljs-title">Car</span> {
    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span> Car <span class="hljs-title">create</span>(<span class="hljs-params" style="color: rgb(102, 0, 102);"> final Supplier< Car > supplier </span>) </span>{
        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">return</span> supplier.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">get</span>();
    }              

    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">void</span> <span class="hljs-title">collide</span>(<span class="hljs-params" style="color: rgb(102, 0, 102);"> final Car car </span>) </span>{
        System.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">out</span>.println( <span class="hljs-string" style="color: rgb(0, 136, 0);">"Collided "</span> + car.toString() );
    }

    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">void</span> <span class="hljs-title">follow</span>(<span class="hljs-params" style="color: rgb(102, 0, 102);"> final Car another </span>) </span>{
        System.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">out</span>.println( <span class="hljs-string" style="color: rgb(0, 136, 0);">"Following the "</span> + another.toString() );
    }

    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">void</span> <span class="hljs-title">repair</span>(<span class="hljs-params" style="color: rgb(102, 0, 102);"></span>) </span>{   
        System.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">out</span>.println( <span class="hljs-string" style="color: rgb(0, 136, 0);">"Repaired "</span> + <span class="hljs-keyword" style="color: rgb(0, 0, 136);">this</span>.toString() );
    }
}</code>

第一种方法引用的类型是构造器引用,语法是Class::new,或者更一般的形式:Class<T>::new。注意:这个构造器没有参数。

<code class="php"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> Car car = Car.create( Car::new );
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">List</span>< Car > cars = Arrays.asList( car );</code>

第二种方法引用的类型是静态方法引用,语法是Class::static_method。注意:这个方法接受一个Car类型的参数。

<code class="css"><span class="hljs-tag">cars</span><span class="hljs-class" style="color: rgb(155, 112, 63);">.forEach</span>( <span class="hljs-rule"><span class="hljs-attribute">Car</span>:<span class="hljs-value">:collide )</span></span>;</code>

第三种方法引用的类型是某个类的成员方法的引用,语法是Class::method,注意,这个方法没有定义入参:

<code class="css"><span class="hljs-tag">cars</span><span class="hljs-class" style="color: rgb(155, 112, 63);">.forEach</span>( <span class="hljs-rule"><span class="hljs-attribute">Car</span>:<span class="hljs-value">:repair )</span></span>;</code>

第四种方法引用的类型是某个实例对象的成员方法的引用,语法是instance::method。注意:这个方法接受一个Car类型的参数:

<code class="php"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> Car police = Car.create( Car::new );
cars.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">forEach</span>( police::follow );</code>

运行上述例子,可以在控制台看到如下输出(Car实例可能不同):

<code class="perl">Collided com.javacodegeeks.java8.method.references.MethodReferences<span class="hljs-variable" style="color: rgb(102, 0, 102);">$Car</span><span class="hljs-variable" style="color: rgb(102, 0, 102);">@7a81197d</span>
Repaired com.javacodegeeks.java8.method.references.MethodReferences<span class="hljs-variable" style="color: rgb(102, 0, 102);">$Car</span><span class="hljs-variable" style="color: rgb(102, 0, 102);">@7a81197d</span>
Following the com.javacodegeeks.java8.method.references.MethodReferences<span class="hljs-variable" style="color: rgb(102, 0, 102);">$Car</span><span class="hljs-variable" style="color: rgb(102, 0, 102);">@7a81197d</span></code>

如果想了解和学习更详细的内容,可以参考官方文档

2.4 重复注解

自从Java 5中引入注解以来,这个特性开始变得非常流行,并在各个框架和项目中被广泛使用。不过,注解有一个很大的限制是:在同一个地方不能多次使用同一个注解。Java 8打破了这个限制,引入了重复注解的概念,允许在同一个地方多次使用同一个注解。

在Java 8中使用@Repeatable注解定义重复注解,实际上,这并不是语言层面的改进,而是编译器做的一个trick,底层的技术仍然相同。可以利用下面的代码说明:

<code class="java"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">package</span> com.javacodegeeks.java8.repeatable.annotations;

<span class="hljs-keyword" style="color: rgb(0, 0, 136);">import</span> java.lang.annotation.ElementType;
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">import</span> java.lang.annotation.Repeatable;
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">import</span> java.lang.annotation.Retention;
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">import</span> java.lang.annotation.RetentionPolicy;
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">import</span> java.lang.annotation.Target;

<span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-class"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">class</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">RepeatingAnnotations</span> </span>{
    <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@Target</span>( ElementType.TYPE )
    <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@Retention</span>( RetentionPolicy.RUNTIME )
    <span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@interface</span> Filters {
        Filter[] value();
    }

    <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@Target</span>( ElementType.TYPE )
    <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@Retention</span>( RetentionPolicy.RUNTIME )
    <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@Repeatable</span>( Filters.class )
    <span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@interface</span> Filter {
        <span class="hljs-function">String <span class="hljs-title">value</span><span class="hljs-params" style="color: rgb(102, 0, 102);">()</span></span>;
    };

    <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@Filter</span>( <span class="hljs-string" style="color: rgb(0, 136, 0);">"filter1"</span> )
    <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@Filter</span>( <span class="hljs-string" style="color: rgb(0, 136, 0);">"filter2"</span> )
    <span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-class"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">interface</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">Filterable</span> </span>{        
    }

    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">void</span> <span class="hljs-title">main</span><span class="hljs-params" style="color: rgb(102, 0, 102);">(String[] args)</span> </span>{
        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">for</span>( Filter filter: Filterable.class.getAnnotationsByType( Filter.class ) ) {
            System.out.println( filter.value() );
        }
    }
}</code>

正如我们所见,这里的Filter类使用@Repeatable(Filters.class)注解修饰,而Filters是存放Filter注解的容器,编译器尽量对开发者屏蔽这些细节。这样,Filterable接口可以用两个Filter注解注释(这里并没有提到任何关于Filters的信息)。

另外,反射API提供了一个新的方法:getAnnotationsByType(),可以返回某个类型的重复注解,例如Filterable.class.getAnnoation(Filters.class)将返回两个Filter实例,输出到控制台的内容如下所示:

<code>filter1
filter2</code>

如果你希望了解更多内容,可以参考官方文档

2.5 更好的类型推断

Java 8编译器在类型推断方面有很大的提升,在很多场景下编译器可以推导出某个参数的数据类型,从而使得代码更为简洁。例子代码如下:

<code class="java"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">package</span> com.javacodegeeks.java8.type.inference;

<span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-class"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">class</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">Value</span>< <span class="hljs-title" style="color: rgb(102, 0, 102);">T</span> > </span>{
    <span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span>< T > <span class="hljs-function">T <span class="hljs-title">defaultValue</span><span class="hljs-params" style="color: rgb(102, 0, 102);">()</span> </span>{ 
        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">return</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">null</span>; 
    }

    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> T <span class="hljs-title">getOrDefault</span><span class="hljs-params" style="color: rgb(102, 0, 102);">( T value, T defaultValue )</span> </span>{
        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">return</span> ( value != <span class="hljs-keyword" style="color: rgb(0, 0, 136);">null</span> ) ? value : defaultValue;
    }
}</code>

下列代码是Value<String>类型的应用:

<code class="cs">package com.javacodegeeks.java8.type.inference;

<span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">class</span> <span class="hljs-title">TypeInference</span> {
    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">void</span> <span class="hljs-title">main</span>(<span class="hljs-params" style="color: rgb(102, 0, 102);">String[] args</span>) </span>{
        final Value< String > <span class="hljs-keyword" style="color: rgb(0, 0, 136);">value</span> = <span class="hljs-keyword" style="color: rgb(0, 0, 136);">new</span> Value<>();
        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">value</span>.getOrDefault( <span class="hljs-string" style="color: rgb(0, 136, 0);">"22"</span>, Value.defaultValue() );
    }
}</code>

参数Value.defaultValue()的类型由编译器推导得出,不需要显式指明。在Java 7中这段代码会有编译错误,除非使用Value.<String>defaultValue()

2.6 拓宽注解的应用场景

Java 8拓宽了注解的应用场景。现在,注解几乎可以使用在任何元素上:局部变量、接口类型、超类和接口实现类,甚至可以用在函数的异常定义上。下面是一些例子:

<code class="java"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">package</span> com.javacodegeeks.java8.annotations;

<span class="hljs-keyword" style="color: rgb(0, 0, 136);">import</span> java.lang.annotation.ElementType;
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">import</span> java.lang.annotation.Retention;
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">import</span> java.lang.annotation.RetentionPolicy;
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">import</span> java.lang.annotation.Target;
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">import</span> java.util.ArrayList;
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">import</span> java.util.Collection;

<span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-class"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">class</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">Annotations</span> </span>{
    <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@Retention</span>( RetentionPolicy.RUNTIME )
    <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@Target</span>( { ElementType.TYPE_USE, ElementType.TYPE_PARAMETER } )
    <span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@interface</span> NonEmpty {        
    }

    <span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span> <span class="hljs-class"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">class</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">Holder</span>< @<span class="hljs-title" style="color: rgb(102, 0, 102);">NonEmpty</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">T</span> > <span class="hljs-keyword" style="color: rgb(0, 0, 136);">extends</span> @<span class="hljs-title" style="color: rgb(102, 0, 102);">NonEmpty</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">Object</span> </span>{
        <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">void</span> <span class="hljs-title">method</span><span class="hljs-params" style="color: rgb(102, 0, 102);">()</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">throws</span> @NonEmpty Exception </span>{            
        }
    }

    <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@SuppressWarnings</span>( <span class="hljs-string" style="color: rgb(0, 136, 0);">"unused"</span> )
    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">void</span> <span class="hljs-title">main</span><span class="hljs-params" style="color: rgb(102, 0, 102);">(String[] args)</span> </span>{
        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> Holder< String > holder = <span class="hljs-keyword" style="color: rgb(0, 0, 136);">new</span> <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@NonEmpty</span> Holder< String >();        
        <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@NonEmpty</span> Collection< <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@NonEmpty</span> String > strings = <span class="hljs-keyword" style="color: rgb(0, 0, 136);">new</span> ArrayList<>();        
    }
}</code>

ElementType.TYPE_USERElementType.TYPE_PARAMETER是Java 8新增的两个注解,用于描述注解的使用场景。Java 语言也做了对应的改变,以识别这些新增的注解。

3. Java编译器的新特性

3.1 参数名称

为了在运行时获得Java程序中方法的参数名称,老一辈的Java程序员必须使用不同方法,例如Paranamer liberary。Java 8终于将这个特性规范化,在语言层面(使用反射API和Parameter.getName()方法)和字节码层面(使用新的javac编译器以及-parameters参数)提供支持。

<code class="java"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">package</span> com.javacodegeeks.java8.parameter.names;

<span class="hljs-keyword" style="color: rgb(0, 0, 136);">import</span> java.lang.reflect.Method;
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">import</span> java.lang.reflect.Parameter;

<span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-class"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">class</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">ParameterNames</span> </span>{
    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">void</span> <span class="hljs-title">main</span><span class="hljs-params" style="color: rgb(102, 0, 102);">(String[] args)</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">throws</span> Exception </span>{
        Method method = ParameterNames.class.getMethod( <span class="hljs-string" style="color: rgb(0, 136, 0);">"main"</span>, String[].class );
        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">for</span>( <span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> Parameter parameter: method.getParameters() ) {
            System.out.println( <span class="hljs-string" style="color: rgb(0, 136, 0);">"Parameter: "</span> + parameter.getName() );
        }
    }
}</code>

在Java 8中这个特性是默认关闭的,因此如果不带-parameters参数编译上述代码并运行,则会输出如下结果:

<code class="mathematica"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">Parameter</span>: arg0</code>

如果带-parameters参数,则会输出如下结果(正确的结果):

<code class="mathematica"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">Parameter</span>: args</code>

如果你使用Maven进行项目管理,则可以在maven-compiler-plugin编译器的配置项中配置-parameters参数:

<code class="xml"><span class="hljs-tag" style="color: rgb(0, 102, 102);"><<span class="hljs-title" style="color: rgb(0, 0, 136);">plugin</span>></span>
    <span class="hljs-tag" style="color: rgb(0, 102, 102);"><<span class="hljs-title" style="color: rgb(0, 0, 136);">groupId</span>></span>org.apache.maven.plugins<span class="hljs-tag" style="color: rgb(0, 102, 102);"></<span class="hljs-title" style="color: rgb(0, 0, 136);">groupId</span>></span>
    <span class="hljs-tag" style="color: rgb(0, 102, 102);"><<span class="hljs-title" style="color: rgb(0, 0, 136);">artifactId</span>></span>maven-compiler-plugin<span class="hljs-tag" style="color: rgb(0, 102, 102);"></<span class="hljs-title" style="color: rgb(0, 0, 136);">artifactId</span>></span>
    <span class="hljs-tag" style="color: rgb(0, 102, 102);"><<span class="hljs-title" style="color: rgb(0, 0, 136);">version</span>></span>3.1<span class="hljs-tag" style="color: rgb(0, 102, 102);"></<span class="hljs-title" style="color: rgb(0, 0, 136);">version</span>></span>
    <span class="hljs-tag" style="color: rgb(0, 102, 102);"><<span class="hljs-title" style="color: rgb(0, 0, 136);">configuration</span>></span>
        <span class="hljs-tag" style="color: rgb(0, 102, 102);"><<span class="hljs-title" style="color: rgb(0, 0, 136);">compilerArgument</span>></span>-parameters<span class="hljs-tag" style="color: rgb(0, 102, 102);"></<span class="hljs-title" style="color: rgb(0, 0, 136);">compilerArgument</span>></span>
        <span class="hljs-tag" style="color: rgb(0, 102, 102);"><<span class="hljs-title" style="color: rgb(0, 0, 136);">source</span>></span>1.8<span class="hljs-tag" style="color: rgb(0, 102, 102);"></<span class="hljs-title" style="color: rgb(0, 0, 136);">source</span>></span>
        <span class="hljs-tag" style="color: rgb(0, 102, 102);"><<span class="hljs-title" style="color: rgb(0, 0, 136);">target</span>></span>1.8<span class="hljs-tag" style="color: rgb(0, 102, 102);"></<span class="hljs-title" style="color: rgb(0, 0, 136);">target</span>></span>
    <span class="hljs-tag" style="color: rgb(0, 102, 102);"></<span class="hljs-title" style="color: rgb(0, 0, 136);">configuration</span>></span>
<span class="hljs-tag" style="color: rgb(0, 102, 102);"></<span class="hljs-title" style="color: rgb(0, 0, 136);">plugin</span>></span></code>

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的例子:可能为空的值或者某个类型的值:

<code class="cs">Optional< String > fullName = Optional.ofNullable( <span class="hljs-keyword" style="color: rgb(0, 0, 136);">null</span> );
System.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">out</span>.println( <span class="hljs-string" style="color: rgb(0, 136, 0);">"Full Name is set? "</span> + fullName.isPresent() );        
System.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">out</span>.println( <span class="hljs-string" style="color: rgb(0, 136, 0);">"Full Name: "</span> + fullName.orElseGet( () -> <span class="hljs-string" style="color: rgb(0, 136, 0);">"[none]"</span> ) ); 
System.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">out</span>.println( fullName.map( s -> <span class="hljs-string" style="color: rgb(0, 136, 0);">"Hey "</span> + s + <span class="hljs-string" style="color: rgb(0, 136, 0);">"!"</span> ).orElse( <span class="hljs-string" style="color: rgb(0, 136, 0);">"Hey Stranger!"</span> ) );</code>

如果Optional实例持有一个非空值,则isPresent()方法返回true,否则返回false;orElseGet()方法,Optional实例持有null,则可以接受一个lambda表达式生成的默认值;map()方法可以将现有的Opetional实例的值转换成新的值;orElse()方法与orElseGet()方法类似,但是在持有null的时候返回传入的默认值。

上述代码的输出结果如下:

<code class="sql">Full Name is <span class="hljs-operator"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">set</span>? <span class="hljs-literal" style="color: rgb(0, 102, 102);">false</span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">Full</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">Name</span>: [<span class="hljs-keyword" style="color: rgb(0, 0, 136);">none</span>]
Hey Stranger!</span></code>

再看下另一个简单的例子:

<code class="swift"><span class="hljs-type">Optional</span>< <span class="hljs-type">String</span> > firstName = <span class="hljs-type">Optional</span>.of( <span class="hljs-string" style="color: rgb(0, 136, 0);">"Tom"</span> );
<span class="hljs-type">System</span>.out.<span class="hljs-built_in" style="color: rgb(102, 0, 102);">println</span>( <span class="hljs-string" style="color: rgb(0, 136, 0);">"First Name is set? "</span> + firstName.isPresent() );        
<span class="hljs-type">System</span>.out.<span class="hljs-built_in" style="color: rgb(102, 0, 102);">println</span>( <span class="hljs-string" style="color: rgb(0, 136, 0);">"First Name: "</span> + firstName.orElseGet( () -> <span class="hljs-string" style="color: rgb(0, 136, 0);">"[none]"</span> ) ); 
<span class="hljs-type">System</span>.out.<span class="hljs-built_in" style="color: rgb(102, 0, 102);">println</span>( firstName.<span class="hljs-built_in" style="color: rgb(102, 0, 102);">map</span>( s -> <span class="hljs-string" style="color: rgb(0, 136, 0);">"Hey "</span> + s + <span class="hljs-string" style="color: rgb(0, 136, 0);">"!"</span> ).orElse( <span class="hljs-string" style="color: rgb(0, 136, 0);">"Hey Stranger!"</span> ) );
<span class="hljs-type">System</span>.out.<span class="hljs-built_in" style="color: rgb(102, 0, 102);">println</span>();</code>

这个例子的输出是:

<code class="sql">First Name is <span class="hljs-operator"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">set</span>? <span class="hljs-literal" style="color: rgb(0, 102, 102);">true</span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">First</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">Name</span>: Tom
Hey Tom!</span></code>

如果想了解更多的细节,请参考官方文档

4.2 Streams

新增的Stream API(java.util.stream)将生成环境的函数式编程引入了Java库中。这是目前为止最大的一次对Java库的完善,以便开发者能够写出更加有效、更加简洁和紧凑的代码。

Steam API极大得简化了集合操作(后面我们会看到不止是集合),首先看下这个叫Task的类:

<code class="java"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-class"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">class</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">Streams</span>  </span>{
    <span class="hljs-keyword" style="color: rgb(0, 0, 136);">private</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">enum</span> Status {
        OPEN, CLOSED
    };

    <span class="hljs-keyword" style="color: rgb(0, 0, 136);">private</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> <span class="hljs-class"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">class</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">Task</span> </span>{
        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">private</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> Status status;
        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">private</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> Integer points;

        Task( <span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> Status status, <span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> Integer points ) {
            <span class="hljs-keyword" style="color: rgb(0, 0, 136);">this</span>.status = status;
            <span class="hljs-keyword" style="color: rgb(0, 0, 136);">this</span>.points = points;
        }

        <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> Integer <span class="hljs-title">getPoints</span><span class="hljs-params" style="color: rgb(102, 0, 102);">()</span> </span>{
            <span class="hljs-keyword" style="color: rgb(0, 0, 136);">return</span> points;
        }

        <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> Status <span class="hljs-title">getStatus</span><span class="hljs-params" style="color: rgb(102, 0, 102);">()</span> </span>{
            <span class="hljs-keyword" style="color: rgb(0, 0, 136);">return</span> status;
        }

        <span class="hljs-annotation" style="color: rgb(155, 133, 157);">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> String <span class="hljs-title">toString</span><span class="hljs-params" style="color: rgb(102, 0, 102);">()</span> </span>{
            <span class="hljs-keyword" style="color: rgb(0, 0, 136);">return</span> String.format( <span class="hljs-string" style="color: rgb(0, 136, 0);">"[%s, %d]"</span>, status, points );
        }
    }
}</code>

Task类有一个分数(或伪复杂度)的概念,另外还有两种状态:OPEN或者CLOSED。现在假设有一个task集合:

<code class="cpp">final Collection< Task > tasks = Arrays.asList(
    <span class="hljs-keyword" style="color: rgb(0, 0, 136);">new</span> Task( Status.OPEN, <span class="hljs-number" style="color: rgb(0, 102, 102);">5</span> ),
    <span class="hljs-keyword" style="color: rgb(0, 0, 136);">new</span> Task( Status.OPEN, <span class="hljs-number" style="color: rgb(0, 102, 102);">13</span> ),
    <span class="hljs-keyword" style="color: rgb(0, 0, 136);">new</span> Task( Status.CLOSED, <span class="hljs-number" style="color: rgb(0, 102, 102);">8</span> ) 
);</code>

首先看一个问题:在这个task集合中一共有多少个OPEN状态的点?在Java 8之前,要解决这个问题,则需要使用foreach循环遍历task集合;但是在Java 8中可以利用steams解决:包括一系列元素的列表,并且支持顺序和并行处理。

<code class="php"><span class="hljs-comment" style="color: rgb(136, 0, 0);">// Calculate total points of all active tasks using sum()</span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> long totalPointsOfOpenTasks = tasks
    .stream()
    .filter( task -> task.getStatus() == Status.OPEN )
    .mapToInt( Task::getPoints )
    .sum();

System.out.println( <span class="hljs-string" style="color: rgb(0, 136, 0);">"Total points: "</span> + totalPointsOfOpenTasks );</code>

运行这个方法的控制台输出是:

<code class="mathematica"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">Total</span> points: <span class="hljs-number" style="color: rgb(0, 102, 102);">18</span></code>

这里有很多知识点值得说。首先,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集合,我们可以用下面的代码计算所有任务的点数之和:

<code class="cpp"><span class="hljs-comment" style="color: rgb(136, 0, 0);">// Calculate total points of all tasks</span>
final <span class="hljs-keyword" style="color: rgb(0, 0, 136);">double</span> totalPoints = tasks
   .stream()
   .parallel()
   .<span class="hljs-built_in" style="color: rgb(102, 0, 102);">map</span>( task -> task.getPoints() ) <span class="hljs-comment" style="color: rgb(136, 0, 0);">// or map( Task::getPoints ) </span>
   .reduce( <span class="hljs-number" style="color: rgb(0, 102, 102);">0</span>, Integer::sum );

System.out.println( <span class="hljs-string" style="color: rgb(0, 136, 0);">"Total points (all tasks): "</span> + totalPoints );</code>

这里我们使用parallel方法并行处理所有的task,并使用reduce方法计算最终的结果。控制台输出如下:

<code class="mathematica"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">Total</span> points(all tasks): <span class="hljs-number" style="color: rgb(0, 102, 102);">26.0</span></code>

对于一个集合,经常需要根据某些条件对其中的元素分组。利用steam提供的API可以很快完成这类任务,代码如下:

<code class="php"><span class="hljs-comment" style="color: rgb(136, 0, 0);">// Group tasks by their status</span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> Map< Status, <span class="hljs-keyword" style="color: rgb(0, 0, 136);">List</span>< Task > > map = tasks
    .stream()
    .collect( Collectors.groupingBy( Task::getStatus ) );
System.out.println( map );</code>

控制台的输出如下:

<code class="cpp">{CLOSED=[[CLOSED, <span class="hljs-number" style="color: rgb(0, 102, 102);">8</span>]], OPEN=[[OPEN, <span class="hljs-number" style="color: rgb(0, 102, 102);">5</span>], [OPEN, <span class="hljs-number" style="color: rgb(0, 102, 102);">13</span>]]}</code>

最后一个关于tasks集合的例子问题是:如何计算集合中每个任务的点数在集合中所占的比重,具体处理的代码如下:

<code class="cpp"><span class="hljs-comment" style="color: rgb(136, 0, 0);">// Calculate the weight of each tasks (as percent of total points) </span>
final Collection< String > result = tasks
    .stream()                                        <span class="hljs-comment" style="color: rgb(136, 0, 0);">// Stream< String ></span>
    .mapToInt( Task::getPoints )                     <span class="hljs-comment" style="color: rgb(136, 0, 0);">// IntStream</span>
    .asLongStream()                                  <span class="hljs-comment" style="color: rgb(136, 0, 0);">// LongStream</span>
    .mapToDouble( points -> points / totalPoints )   <span class="hljs-comment" style="color: rgb(136, 0, 0);">// DoubleStream</span>
    .boxed()                                         <span class="hljs-comment" style="color: rgb(136, 0, 0);">// Stream< Double ></span>
    .mapToLong( weigth -> ( <span class="hljs-keyword" style="color: rgb(0, 0, 136);">long</span> )( weigth * <span class="hljs-number" style="color: rgb(0, 102, 102);">100</span> ) ) <span class="hljs-comment" style="color: rgb(136, 0, 0);">// LongStream</span>
    .mapToObj( percentage -> percentage + <span class="hljs-string" style="color: rgb(0, 136, 0);">"%"</span> )      <span class="hljs-comment" style="color: rgb(136, 0, 0);">// Stream< String> </span>
    .collect( Collectors.toList() );                 <span class="hljs-comment" style="color: rgb(136, 0, 0);">// List< String > </span>

System.out.println( result );</code>

控制台输出结果如下:

<code class="json">[<span class="hljs-number" style="color: rgb(0, 102, 102);">19</span>%, <span class="hljs-number" style="color: rgb(0, 102, 102);">50</span>%, <span class="hljs-number" style="color: rgb(0, 102, 102);">30</span>%]</code>

最后,正如之前所说,Steam API不仅可以作用于Java集合,传统的IO操作(从文件或者网络一行一行得读取数据)可以受益于steam处理,这里有一个小例子:

<code class="php"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> Path path = <span class="hljs-keyword" style="color: rgb(0, 0, 136);">new</span> File( filename ).toPath();
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">try</span>( Stream< String > lines = Files.lines( path, StandardCharsets.UTF_8 ) ) {
    lines.onClose( () -> System.out.println(<span class="hljs-string" style="color: rgb(0, 136, 0);">"Done!"</span>) ).<span class="hljs-keyword" style="color: rgb(0, 0, 136);">forEach</span>( System.out::println );
}</code>

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

<code class="cs"><span class="hljs-comment" style="color: rgb(136, 0, 0);">// Get the system clock as UTC offset </span>
final Clock clock = Clock.systemUTC();
System.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">out</span>.println( clock.instant() );
System.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">out</span>.println( clock.millis() );</code>

这个例子的输出结果是:

<code class="cpp"><span class="hljs-number" style="color: rgb(0, 102, 102);">2014</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">04</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">12</span>T15:<span class="hljs-number" style="color: rgb(0, 102, 102);">19</span>:<span class="hljs-number" style="color: rgb(0, 102, 102);">29.282</span>Z
<span class="hljs-number" style="color: rgb(0, 102, 102);">1397315969360</span></code>

第二,关注下LocalDateLocalTime类。LocalDate仅仅包含ISO-8601日历系统中的日期部分;LocalTime则仅仅包含该日历系统中的时间部分。这两个类的对象都可以使用Clock对象构建得到。

<code class="perl">// Get the <span class="hljs-keyword" style="color: rgb(0, 0, 136);">local</span> date <span class="hljs-keyword" style="color: rgb(0, 0, 136);">and</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">local</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">time</span>
final LocalDate date = LocalDate.now();
final LocalDate dateFromClock = LocalDate.now( clock );

System.out.println( date );
System.out.println( dateFromClock );

<span class="hljs-regexp" style="color: rgb(0, 136, 0);">//</span> Get the <span class="hljs-keyword" style="color: rgb(0, 0, 136);">local</span> date <span class="hljs-keyword" style="color: rgb(0, 0, 136);">and</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">local</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">time</span>
final LocalTime <span class="hljs-keyword" style="color: rgb(0, 0, 136);">time</span> = LocalTime.now();
final LocalTime timeFromClock = LocalTime.now( clock );

System.out.println( <span class="hljs-keyword" style="color: rgb(0, 0, 136);">time</span> );
System.out.println( timeFromClock );</code>

上述例子的输出结果如下:

<code class="cpp"><span class="hljs-number" style="color: rgb(0, 102, 102);">2014</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">04</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">12</span>
<span class="hljs-number" style="color: rgb(0, 102, 102);">2014</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">04</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">12</span>
<span class="hljs-number" style="color: rgb(0, 102, 102);">11</span>:<span class="hljs-number" style="color: rgb(0, 102, 102);">25</span>:<span class="hljs-number" style="color: rgb(0, 102, 102);">54.568</span>
<span class="hljs-number" style="color: rgb(0, 102, 102);">15</span>:<span class="hljs-number" style="color: rgb(0, 102, 102);">25</span>:<span class="hljs-number" style="color: rgb(0, 102, 102);">54.568</span></code>

LocalDateTime类包含了LocalDate和LocalTime的信息,但是不包含ISO-8601日历系统中的时区信息。这里有一些关于LocalDate和LocalTime的例子

<code class="scala"><span class="hljs-comment" style="color: rgb(136, 0, 0);">// Get the local date/time</span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> <span class="hljs-type">LocalDateTime</span> datetime = <span class="hljs-type">LocalDateTime</span>.now();
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> <span class="hljs-type">LocalDateTime</span> datetimeFromClock = <span class="hljs-type">LocalDateTime</span>.now( clock );

<span class="hljs-type">System</span>.out.println( datetime );
<span class="hljs-type">System</span>.out.println( datetimeFromClock );</code>

上述这个例子的输出结果如下:

<code class="cpp"><span class="hljs-number" style="color: rgb(0, 102, 102);">2014</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">04</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">12</span>T11:<span class="hljs-number" style="color: rgb(0, 102, 102);">37</span>:<span class="hljs-number" style="color: rgb(0, 102, 102);">52.309</span>
<span class="hljs-number" style="color: rgb(0, 102, 102);">2014</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">04</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">12</span>T15:<span class="hljs-number" style="color: rgb(0, 102, 102);">37</span>:<span class="hljs-number" style="color: rgb(0, 102, 102);">52.309</span></code>

如果你需要特定时区的data/time信息,则可以使用ZoneDateTime,它保存有ISO-8601日期系统的日期和时间,而且有时区信息。下面是一些使用不同时区的例子:

<code class="scala"><span class="hljs-comment" style="color: rgb(136, 0, 0);">// Get the zoned date/time</span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> <span class="hljs-type">ZonedDateTime</span> zonedDatetime = <span class="hljs-type">ZonedDateTime</span>.now();
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> <span class="hljs-type">ZonedDateTime</span> zonedDatetimeFromClock = <span class="hljs-type">ZonedDateTime</span>.now( clock );
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> <span class="hljs-type">ZonedDateTime</span> zonedDatetimeFromZone = <span class="hljs-type">ZonedDateTime</span>.now( <span class="hljs-type">ZoneId</span>.of( <span class="hljs-string" style="color: rgb(0, 136, 0);">"America/Los_Angeles"</span> ) );

<span class="hljs-type">System</span>.out.println( zonedDatetime );
<span class="hljs-type">System</span>.out.println( zonedDatetimeFromClock );
<span class="hljs-type">System</span>.out.println( zonedDatetimeFromZone );</code>

这个例子的输出结果是:

<code class="cpp"><span class="hljs-number" style="color: rgb(0, 102, 102);">2014</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">04</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">12</span>T11:<span class="hljs-number" style="color: rgb(0, 102, 102);">47</span>:<span class="hljs-number" style="color: rgb(0, 102, 102);">01.017</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">04</span>:<span class="hljs-number" style="color: rgb(0, 102, 102);">00</span>[America/New_York]
<span class="hljs-number" style="color: rgb(0, 102, 102);">2014</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">04</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">12</span>T15:<span class="hljs-number" style="color: rgb(0, 102, 102);">47</span>:<span class="hljs-number" style="color: rgb(0, 102, 102);">01.017</span>Z
<span class="hljs-number" style="color: rgb(0, 102, 102);">2014</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">04</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">12</span>T08:<span class="hljs-number" style="color: rgb(0, 102, 102);">47</span>:<span class="hljs-number" style="color: rgb(0, 102, 102);">01.017</span>-<span class="hljs-number" style="color: rgb(0, 102, 102);">07</span>:<span class="hljs-number" style="color: rgb(0, 102, 102);">00</span>[America/Los_Angeles]</code>

最后看下Duration类,它持有的时间精确到秒和纳秒。这使得我们可以很容易得计算两个日期之间的不同,例子代码如下:

<code class="cpp"><span class="hljs-comment" style="color: rgb(136, 0, 0);">// Get duration between two dates</span>
final LocalDateTime from = LocalDateTime.of( <span class="hljs-number" style="color: rgb(0, 102, 102);">2014</span>, Month.APRIL, <span class="hljs-number" style="color: rgb(0, 102, 102);">16</span>, <span class="hljs-number" style="color: rgb(0, 102, 102);">0</span>, <span class="hljs-number" style="color: rgb(0, 102, 102);">0</span>, <span class="hljs-number" style="color: rgb(0, 102, 102);">0</span> );
final LocalDateTime to = LocalDateTime.of( <span class="hljs-number" style="color: rgb(0, 102, 102);">2015</span>, Month.APRIL, <span class="hljs-number" style="color: rgb(0, 102, 102);">16</span>, <span class="hljs-number" style="color: rgb(0, 102, 102);">23</span>, <span class="hljs-number" style="color: rgb(0, 102, 102);">59</span>, <span class="hljs-number" style="color: rgb(0, 102, 102);">59</span> );

final Duration duration = Duration.between( from, to );
System.out.println( <span class="hljs-string" style="color: rgb(0, 136, 0);">"Duration in days: "</span> + duration.toDays() );
System.out.println( <span class="hljs-string" style="color: rgb(0, 136, 0);">"Duration in hours: "</span> + duration.toHours() );</code>

这个例子用于计算2014年4月16日和2015年4月16日之间的天数和小时数,输出结果如下:

<code class="objectivec">Duration <span class="hljs-keyword" style="color: rgb(0, 0, 136);">in</span> days: <span class="hljs-number" style="color: rgb(0, 102, 102);">365</span>
Duration <span class="hljs-keyword" style="color: rgb(0, 0, 136);">in</span> hours: <span class="hljs-number" style="color: rgb(0, 102, 102);">8783</span></code>

对于Java 8的新日期时间的总体印象还是比较积极的,一部分是因为Joda-Time的积极影响,另一部分是因为官方终于听取了开发人员的需求。如果希望了解更多细节,可以参考官方文档

4.4 Nashorn JavaScript引擎

Java 8提供了新的Nashorn JavaScript引擎,使得我们可以在JVM上开发和运行JS应用。Nashorn JavaScript引擎是javax.script.ScriptEngine的另一个实现版本,这类Script引擎遵循相同的规则,允许Java和JavaScript交互使用,例子代码如下:

<code class="cs">ScriptEngineManager manager = <span class="hljs-keyword" style="color: rgb(0, 0, 136);">new</span> ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName( <span class="hljs-string" style="color: rgb(0, 136, 0);">"JavaScript"</span> );

System.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">out</span>.println( engine.getClass().getName() );
System.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">out</span>.println( <span class="hljs-string" style="color: rgb(0, 136, 0);">"Result:"</span> + engine.eval( <span class="hljs-string" style="color: rgb(0, 136, 0);">"function f() { return 1; }; f() + 1;"</span> ) );</code>

这个代码的输出结果如下:

<code class="css"><span class="hljs-tag">jdk</span><span class="hljs-class" style="color: rgb(155, 112, 63);">.nashorn</span><span class="hljs-class" style="color: rgb(155, 112, 63);">.api</span><span class="hljs-class" style="color: rgb(155, 112, 63);">.scripting</span><span class="hljs-class" style="color: rgb(155, 112, 63);">.NashornScriptEngine</span>
<span class="hljs-rule"><span class="hljs-attribute">Result</span>:<span class="hljs-value"> <span class="hljs-number" style="color: rgb(0, 102, 102);">2</span></span></span></code>

4.5 Base64

对Base64编码的支持已经被加入到Java 8官方库中,这样不需要使用第三方库就可以进行Base64编码,例子代码如下:

<code class="java"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">package</span> com.javacodegeeks.java8.base64;

<span class="hljs-keyword" style="color: rgb(0, 0, 136);">import</span> java.nio.charset.StandardCharsets;
<span class="hljs-keyword" style="color: rgb(0, 0, 136);">import</span> java.util.Base64;

<span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-class"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">class</span> <span class="hljs-title" style="color: rgb(102, 0, 102);">Base64s</span> </span>{
    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">void</span> <span class="hljs-title">main</span><span class="hljs-params" style="color: rgb(102, 0, 102);">(String[] args)</span> </span>{
        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> String text = <span class="hljs-string" style="color: rgb(0, 136, 0);">"Base64 finally in Java 8!"</span>;

        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> String encoded = Base64
            .getEncoder()
            .encodeToString( text.getBytes( StandardCharsets.UTF_8 ) );
        System.out.println( encoded );

        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">final</span> String decoded = <span class="hljs-keyword" style="color: rgb(0, 0, 136);">new</span> String( 
            Base64.getDecoder().decode( encoded ),
            StandardCharsets.UTF_8 );
        System.out.println( decoded );
    }
}</code>

这个例子的输出结果如下:

<code class="python">QmFzZTY0IGZpbmFsbHkgaW4gSmF2YSA4IQ==
Base64 <span class="hljs-keyword" style="color: rgb(0, 0, 136);">finally</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">in</span> Java <span class="hljs-number" style="color: rgb(0, 102, 102);">8</span>!</code>

新的Base64API也支持URL和MINE的编码解码。
(Base64.getUrlEncoder() / Base64.getUrlDecoder()Base64.getMimeEncoder() / Base64.getMimeDecoder())。

4.6 并行数组

Java8版本新增了很多新的方法,用于支持并行数组处理。最重要的方法是parallelSort(),可以显著加快多核机器上的数组排序。下面的例子论证了parallexXxx系列的方法:

<code class="cs">package com.javacodegeeks.java8.parallel.arrays;

import java.util.Arrays;
import java.util.concurrent.ThreadLocalRandom;

<span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">class</span> <span class="hljs-title">ParallelArrays</span> {
    <span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">static</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">void</span> <span class="hljs-title">main</span>(<span class="hljs-params" style="color: rgb(102, 0, 102);"> String[] args </span>) </span>{
        <span class="hljs-keyword" style="color: rgb(0, 0, 136);">long</span>[] arrayOfLong = <span class="hljs-keyword" style="color: rgb(0, 0, 136);">new</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136);">long</span> [ <span class="hljs-number" style="color: rgb(0, 102, 102);">20000</span> ];        

        Arrays.parallelSetAll( arrayOfLong, 
            index -> ThreadLocalRandom.current().nextInt( <span class="hljs-number" style="color: rgb(0, 102, 102);">1000000</span> ) );
        Arrays.stream( arrayOfLong ).limit( <span class="hljs-number" style="color: rgb(0, 102, 102);">10</span> ).forEach( 
            i -> System.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">out</span>.print( i + <span class="hljs-string" style="color: rgb(0, 136, 0);">" "</span> ) );
        System.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">out</span>.println();

        Arrays.parallelSort( arrayOfLong );        
        Arrays.stream( arrayOfLong ).limit( <span class="hljs-number" style="color: rgb(0, 102, 102);">10</span> ).forEach( 
            i -> System.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">out</span>.print( i + <span class="hljs-string" style="color: rgb(0, 136, 0);">" "</span> ) );
        System.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">out</span>.println();
    }
}</code>

上述这些代码使用parallelSetAll()方法生成20000个随机数,然后使用parallelSort()方法进行排序。这个程序会输出乱序数组和排序数组的前10个元素。上述例子的代码输出的结果是:

<code class="cpp">Unsorted: <span class="hljs-number" style="color: rgb(0, 102, 102);">591217</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">891976</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">443951</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">424479</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">766825</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">351964</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">242997</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">642839</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">119108</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">552378</span> 
Sorted: <span class="hljs-number" style="color: rgb(0, 102, 102);">39</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">220</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">263</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">268</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">325</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">607</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">655</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">678</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">723</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">793</span></code>

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文件,内容如下:

<code class="php"><span class="hljs-function"><span class="hljs-keyword" style="color: rgb(0, 0, 136);">function</span> <span class="hljs-title">f</span><span class="hljs-params" style="color: rgb(102, 0, 102);">()</span> </span>{ 
     <span class="hljs-keyword" style="color: rgb(0, 0, 136);">return</span> <span class="hljs-number" style="color: rgb(0, 102, 102);">1</span>; 
}; 

<span class="hljs-keyword" style="color: rgb(0, 0, 136);">print</span>( f() + <span class="hljs-number" style="color: rgb(0, 102, 102);">1</span> );</code>

可以在命令行中执行这个命令:jjs func.js,控制台输出结果是:

<code class="cpp">2</code>

如果需要了解细节,可以参考官方文档

5.2 类依赖分析器:jdeps

jdeps是一个相当棒的命令行工具,它可以展示包层级和类层级的Java类依赖关系,它以.class文件、目录或者Jar文件为输入,然后会把依赖关系输出到控制台。

我们可以利用jedps分析下Spring Framework库,为了让结果少一点,仅仅分析一个JAR文件:org.springframework.core-3.0.5.RELEASE.jar

<code class="css"><span class="hljs-tag">jdeps</span> <span class="hljs-tag">org</span><span class="hljs-class" style="color: rgb(155, 112, 63);">.springframework</span><span class="hljs-class" style="color: rgb(155, 112, 63);">.core-3</span><span class="hljs-class" style="color: rgb(155, 112, 63);">.0</span><span class="hljs-class" style="color: rgb(155, 112, 63);">.5</span><span class="hljs-class" style="color: rgb(155, 112, 63);">.RELEASE</span><span class="hljs-class" style="color: rgb(155, 112, 63);">.jar</span></code>

这个命令会输出很多结果,我们仅看下其中的一部分:依赖关系按照包分组,如果在classpath上找不到依赖,则显示"not found".

<code class="cpp">org.springframework.core-<span class="hljs-number" style="color: rgb(0, 102, 102);">3.0</span><span class="hljs-number" style="color: rgb(0, 102, 102);">.5</span>.RELEASE.jar -> C:\Program Files\Java\jdk1<span class="hljs-number" style="color: rgb(0, 102, 102);">.8</span><span class="hljs-number" style="color: rgb(0, 102, 102);">.0</span>\jre\lib\rt.jar
   org.springframework.core (org.springframework.core-<span class="hljs-number" style="color: rgb(0, 102, 102);">3.0</span><span class="hljs-number" style="color: rgb(0, 102, 102);">.5</span>.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.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">asm</span>                            not found
      -> org.springframework.<span class="hljs-keyword" style="color: rgb(0, 0, 136);">asm</span>.commons                    not found
   org.springframework.core.annotation (org.springframework.core-<span class="hljs-number" style="color: rgb(0, 102, 102);">3.0</span><span class="hljs-number" style="color: rgb(0, 102, 102);">.5</span>.RELEASE.jar)
      -> java.lang                                          
      -> java.lang.annotation                               
      -> java.lang.reflect                                  
      -> java.util</code>

更多的细节可以参考官方文档

6. JVM的新特性

使用MetaspaceJEP 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. 参考资料

目录
相关文章
|
10天前
|
Java API
Java 8新特性之Lambda表达式与Stream API
【5月更文挑战第17天】本文将介绍Java 8中的两个重要特性:Lambda表达式和Stream API。Lambda表达式是一种新的编程语法,它允许我们将函数作为参数传递给其他方法,从而使代码更加简洁。Stream API是一种用于处理集合的新工具,它提供了一种高效且易于使用的方式来处理数据。通过结合使用这两个特性,我们可以编写出更加简洁、高效的Java代码。
21 0
|
4天前
|
Java API
Java 8新特性之Lambda表达式与Stream API
本文将介绍Java 8中的两个重要特性:Lambda表达式和Stream API。Lambda表达式是一种新的编程语法,可以使代码更简洁、易读。Stream API是一种处理数据的新方式,可以让我们更方便地对集合进行操作。通过学习这两个特性,我们可以编写出更简洁、高效的Java代码。
|
4天前
|
Java
Java 8新特性之Lambda表达式
【5月更文挑战第23天】本文将介绍Java 8中的一个重要新特性——Lambda表达式。Lambda表达式是Java 8引入的一种新的编程语法,它允许我们将函数作为参数传递给其他方法,从而简化代码并提高可读性。文章将从Lambda表达式的基本概念、语法结构、使用方法以及与匿名内部类的比较等方面进行详细讲解。
3 0
|
5天前
|
Java 编译器 C语言
java类和对象的基础特性-2
java类和对象的基础特性
6 0
|
5天前
|
算法 Java 数据安全/隐私保护
java类和对象的基础特性-1
java类和对象的基础特性
7 0
java类和对象的基础特性-1
|
6天前
|
分布式计算 Java 程序员
Java 8新特性之Lambda表达式与Stream API
【5月更文挑战第21天】本文主要介绍了Java 8中的两个重要新特性:Lambda表达式和Stream API。Lambda表达式是Java 8引入的一种新的编程方式,它允许我们将函数作为参数传递给其他方法。而Stream API则是一种新的数据处理方式,它允许我们以声明式的方式处理数据,使得代码更加简洁易读。
|
6天前
|
并行计算 Java 大数据
Java 8新特性解析及应用
【5月更文挑战第21天】本文将深入探讨Java 8的新特性,包括Lambda表达式、Stream API、Optional类以及新的日期时间API。我们将详细解析这些特性的使用方法和应用场景,帮助读者更好地理解和应用Java 8的新特性。
|
7天前
|
Java API
Java 8新特性之Lambda表达式
【5月更文挑战第20天】本文将介绍Java 8中的一个重要特性——Lambda表达式。Lambda表达式是Java 8引入的一种新的编程语法,它允许我们将函数作为参数传递给方法,从而实现更加简洁、灵活的代码。本文将从Lambda表达式的基本概念、语法、使用方法以及优缺点等方面进行详细介绍,帮助读者更好地理解和应用Lambda表达式。
|
1天前
|
缓存 Java
Java并发编程:深入理解线程池
【5月更文挑战第26天】本文将深入探讨Java并发编程中的一个重要概念——线程池。我们将了解线程池的基本概念,它的工作原理,以及如何在Java中使用线程池。此外,我们还将讨论线程池的优点和缺点,以及在实际应用中如何选择合适的线程池策略。
|
1天前
|
Java 开发者
Java中的多线程编程:基础知识与实践
【5月更文挑战第26天】 在现代计算机科学中,多线程编程是一个复杂且强大的概念。Java作为一种广泛使用的编程语言,其对多线程的支持使得开发者能够创建出更为复杂、高效和响应迅速的应用程序。本文将深入探讨Java中的多线程编程,从基础概念到实际编程技巧,为读者提供全面的理解和实践指导。