前言: 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。本文还参考了一些其他资料,例如:15 Must Read Java 8 Tutorials和The Dark Side of Java 8。本文综合了上述资料,整理成一份关于Java 8新特性的参考教材,希望你有所收获。
- 简介
======
毫无疑问,Java 8是Java自Java 5(发布于2004年)之后的最重要的版本。这个版本包含语言、编译器、库、工具和JVM等方面的十多个新特性。在本文中我们将学习这些新特性,并用实际的例子说明在什么场景下适合使用。
这个教程包含Java开发者经常面对的几类问题:
- 语言
- 编译器
- 库
- 工具
- 运行时(JVM)
- Java语言的新特性
==============
Java 8是Java的一个重大版本,有人认为,虽然这些新特性领Java开发人员十分期待,但同时也需要花不少精力去学习。在这一小节中,我们将介绍Java 8的大部分新特性。
2.1 Lambda表达式和函数式接口
Lambda表达式(也称为闭包)是Java 8中最大和最令人期待的语言改变。它允许我们将函数当成参数传递给某个方法,或者把代码本身当作数据处理:函数式开发者非常熟悉这些概念。很多JVM平台上的语言(Groovy、Scala等)从诞生之日就支持Lambda表达式,但是Java开发者没有选择,只能使用匿名内部类代替Lambda表达式。
Lambda的设计耗费了很多时间和很大的社区力量,最终找到一种折中的实现方案,可以实现简洁而紧凑的语言结构。最简单的Lambda表达式可由逗号分隔的参数列表、**->**符号和语句块组成,例如:
Arrays.asList( "a", "b", "d" ).forEach( e -> System.out.println( e ) );
在上面这个代码中的参数e的类型是由编译器推理得出的,你也可以显式指定该参数的类型,例如:
Arrays.asList( "a", "b", "d" ).forEach( ( String e ) -> System.out.println( e ) );
如果Lambda表达式需要更复杂的语句块,则可以使用花括号将该语句块括起来,类似于Java中的函数体,例如:
1. `Arrays.asList( "a", "b", "d" ).forEach( e -> {
`
2. `System.out.print( e );`
3. `System.out.print( e );`
4. `} );`
Lambda表达式可以引用类成员和局部变量(会将这些变量隐式得转换成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语句,下列两个代码片段效果相同:
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表达式良好兼容,考虑了很多方法,于是产生了**函数接口这个概念。函数接口指的是只有一个函数的接口,这样的接口可以隐式转换为Lambda表达式。java.lang.Runnable和java.util.concurrent.Callable是函数式接口的最佳例子。在实践中,函数式接口非常脆弱:只要某个开发者在该接口中添加一个函数,则该接口就不再是函数式接口进而导致编译失败。为了克服这种代码层面的脆弱性,并显式说明某个接口是函数式接口,Java 8 提供了一个特殊的注解@FunctionalInterface**(Java 库中的所有相关接口都已经带有这个注解了),举个简单的函数式接口的定义:
1. `@FunctionalInterface`
2. `public interface Functional {
`
3. `void method();`
4. `}`
不过有一点需要注意,默认方法和静态方法不会破坏函数式接口的定义,因此如下的代码是合法的。
1. `@FunctionalInterface`
2. `public interface FunctionalDefaultMethods {
`
3. `void method();`
5. `default void defaultMethod() {
`
6. `}`
7. `}`
Lambda表达式作为Java 8的最大卖点,它有潜力吸引更多的开发者加入到JVM平台,并在纯Java编程中使用函数式编程的概念。如果你需要了解更多Lambda表达式的细节,可以参考官方文档。
2.2 接口的默认方法和静态方法
Java 8使用两个新概念扩展了接口的含义:默认方法和静态方法。默认方法使得接口有点类似traits,不过要实现的目标不一样。默认方法使得开发者可以在 不破坏二进制兼容性的前提下,往现存接口中添加新的方法,即不强制那些实现了该接口的类也同时实现这个新加的方法。
默认方法和抽象方法之间的区别在于抽象方法需要实现,而默认方法不需要。接口提供的默认方法会被接口的实现类继承或者覆写,例子代码如下:
1. `private interface Defaulable {
`
2. `// Interfaces now allow default methods, the implementer may or`
3. `// may not implement (override) them.`
4. `default String notRequired() {
`
5. `return "Default implementation";`
6. `}`
7. `}`
9. `private static class DefaultableImpl implements Defaulable {
`
10. `}`
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() );`
5. `defaulable = DefaulableFactory.create( OverridableImpl::new );`
6. `System.out.println( defaulable.notRequired() );`
7. `}`
这段代码的输出结果如下:
1. `Default implementation`
2. `Overridden implementation`
由于JVM上的默认方法的实现在字节码层面提供了支持,因此效率非常高。默认方法允许在不打破现有继承体系的基础上改进接口。该特性在官方库中的应用是:给java.util.Collection接口添加新方法,如stream()、parallelStream()、**forEach()和removeIf()**等等。
尽管默认方法有这么多好处,但在实际开发中应该谨慎使用:在复杂的继承体系中,默认方法可能引起歧义和编译错误。如果你想了解更多细节,可以参考官方文档。
2.3 方法引用
方法引用使得开发者可以直接引用现存的方法、Java类的构造方法或者实例对象。方法引用和Lambda表达式配合使用,使得java类的构造方法看起来紧凑而简洁,没有很多复杂的模板代码。
西门的例子中,Car类是不同方法引用的例子,可以帮助读者区分四种类型的方法引用。
1. public static class Car {
2. public static Car create( final Supplier< Car > supplier ) {
3. return supplier.get();
4. }
6. public static void collide( final Car car ) {
7. System.out.println( "Collided " + car.toString() );
8. }
10. public void follow( final Car another ) {
11. System.out.println( "Following the " + another.toString() );
12. }
14. public void repair() {
15. System.out.println( "Repaired " + this.toString() );
16. }
17. }
第一种方法引用的类型是构造器引用,语法是Class::new,或者更一般的形式:Class::new。注意:这个构造器没有参数。
1. `final Car car = Car.create( Car::new );`
2. `final List< Car > cars = Arrays.asList( car );`
第二种方法引用的类型是静态方法引用,语法是Class::static_method。注意:这个方法接受一个Car类型的参数。
`cars.forEach( Car::collide );`
第三种方法引用的类型是某个类的成员方法的引用,语法是Class::method,注意,这个方法没有定义入参:
`cars.forEach( Car::repair );`
第四种方法引用的类型是某个实例对象的成员方法的引用,语法是instance::method。注意:这个方法接受一个Car类型的参数:
1. `final Car police = Car.create( Car::new );`
2. `cars.forEach( police::follow );`
运行上述例子,可以在控制台看到如下输出(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
如果想了解和学习更详细的内容,可以参考官方文档