Java8的新特性

参考文章：

http://blog.csdn.net/yczz/article/details/50896975

https://www.javacodegeeks.com/2014/05/java-8-features-tutorial.html

 1、语言的新特性

  1.1、Lambda表达式

// 参数类型编译器推理
Arrays.asList( "a", "b", "d" ).forEach( e -> System.out.println( e ) );
// 参数类型显示指定
Arrays.asList( "a", "b", "d" ).forEach( ( String e ) -> System.out.println( e ) );
// 代码块
Arrays.asList( "a", "b", "d" ).forEach( e -> {
System.out.print( e );
System.out.print( e );
} );
// 返回值编译器推理
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;
} );
// 变量隐式转成final
String separator = ",";
Arrays.asList( "a", "b", "d" ).forEach( ( String e ) -> System.out.print( e + separator ) );
// 变量显示指定final
final String separator = ",";
Arrays.asList( "a", "b", "d" ).forEach( ( String e ) -> System.out.print( e + separator ) );

 1.2、函数式接口@FunctionalInterface

函数式接口指的是只有一个函数的接口，这样的接口可以隐式转换为Lambda表达式。java.lang.Runnable和java.util.concurrent.Callable是函数式接口的最佳例子。
在实践中，函数式接口非常脆弱：只要某个开发者在该接口中添加一个函数，则该接口就不再是函数式接口进而导致编译失败。为了克服这种代码层面的脆弱性，并显式说明某个接口是函数式接口，Java 8 提供了一个特殊的注解@FunctionalInterface
函数式接口的定义：

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

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

@FunctionalInterface
public interface FunctionalDefaultStaticMethods {
    void method();
    default void defaultMethod() {
    }
    static void staticMethod() {
    }
}

Lambda表达式的细节，可以参考官方文档：https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

 1.3、接口默认方法和静态方法

默认方法是使用default关键字定义的一个默认方法。默认方法和抽象方法之间的区别在于抽象方法需要实现，而默认方法不需要。接口提供的默认方法会被接口的实现类继承或者覆写，
例子代码如下：

private interface Defaulable {
    default String notRequired() { 
        return "Default implementation";
    }
    static String staticMethod() { 
        return "static";
    }
}

private static class DefaultableImpl implements Defaulable {
}

private static class OverridableImpl implements Defaulable {
    @Override
    public String notRequired() {
        return "Overridden implementation";
    }
}

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

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.util.Collection接口添加新方法，如stream()、parallelStream()、forEach()和removeIf()等等。尽管默认方法有这么多好处，但在实际开发中应该谨慎使用：在复杂的继承体系中，默认方法可能引起歧义和编译错误。

如果你想了解更多细节，可以参考官方文档：https://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html