java8新特性(1)-lambda

Lambda 表达式简介

Lambda 表达式是一种匿名函数(对 Java 而言这并不彻底正确，但如今姑且这么认为)，简单地说，它是没有声明的方法，也即没有访问修饰符、返回值声明和名字。

你能够将其想作一种速记，在你须要使用某个方法的地方写上它。当某个方法只使用一次，并且定义很简短，使用这种速记替代之尤为有效，这样，你就没必要在类中费力写声明与方法了。

Java 中的 Lambda 表达式一般使用 (argument) -> (body) 语法书写，例如：

(arg1, arg2...) -> { body }

(type1 arg1, type2 arg2...) -> { body }

如下是一些 Lambda 表达式的例子：

(int a, int b) -> {  return a + b; }

() -> System.out.println("Hello World");

(String s) -> { System.out.println(s); }

() -> 42

() -> { return 3.1415 };

Lambda 表达式的结构

让咱们了解一下 Lambda 表达式的结构。

• 一个 Lambda 表达式能够有零个或多个参数

• 参数的类型既能够明确声明，也能够根据上下文来推断。例如：(int a)与(a)效果相同

• 全部参数需包含在圆括号内，参数之间用逗号相隔。例如：(a, b) 或 (int a, int b) 或 (String a, int b, float c)

• 空圆括号表明参数集为空。例如：() -> 42

• 当只有一个参数，且其类型可推导时，圆括号（）可省略。例如：a -> return a*a

• Lambda 表达式的主体可包含零条或多条语句

• 若是 Lambda 表达式的主体只有一条语句，花括号{}可省略。匿名函数的返回类型与该主体表达式一致

• 若是 Lambda 表达式的主体包含一条以上语句，则表达式必须包含在花括号{}中（造成代码块）。匿名函数的返回类型与代码块的返回类型一致，若没有返回则为空

  
  

什么是函数式接口

在 Java 中，Marker（标记）类型的接口是一种没有方法或属性声明的接口，简单地说，marker 接口是空接口。类似地，函数式接口是只包含一个抽象方法声明的接口。

java.lang.Runnable 就是一种函数式接口，在 Runnable 接口中只声明了一个方法 void run()，类似地，ActionListener 接口也是一种函数式接口，咱们使用匿名内部类来实例化函数式接口的对象，有了 Lambda 表达式，这一方式能够获得简化。

每一个 Lambda 表达式都能隐式地赋值给函数式接口，例如，咱们能够经过 Lambda 表达式建立 Runnable 接口的引用。

Runnable r = () -> System.out.println("hello world");

当不指明函数式接口时，编译器会自动解释这种转化：

new Thread(
   () -> System.out.println("hello world")
).start();

所以，在上面的代码中，编译器会自动推断：根据线程类的构造函数签名 public Thread(Runnable r) { }，将该 Lambda 表达式赋给 Runnable 接口。

如下是一些 Lambda 表达式及其函数式接口：

Consumer<Integer>  c = (int x) -> { System.out.println(x) };

BiConsumer<Integer, String> b = (Integer x, String y) -> System.out.println(x + " : " + y);

Predicate<String> p = (String s) -> { s == null };

@FunctionalInterface 是 Java 8 新加入的一种接口，用于指明该接口类型声明是根据 Java 语言规范定义的函数式接口。Java 8 还声明了一些 Lambda 表达式可使用的函数式接口，当你注释的接口不是有效的函数式接口时，可使用 @FunctionalInterface 解决编译层面的错误。

如下是一种自定义的函数式接口：    @FunctionalInterface    public interface WorkerInterface {

   public void doSomeWork();

}

根据定义，函数式接口只能有一个抽象方法，若是你尝试添加第二个抽象方法，将抛出编译时错误。例如：

@FunctionalInterface
public interface WorkerInterface {

    public void doSomeWork();

    public void doSomeMoreWork();

}

错误：

Unexpected @FunctionalInterface annotation 
    @FunctionalInterface ^ WorkerInterface is not a functional interface multiple 
    non-overriding abstract methods found in interface WorkerInterface 1 error

函数式接口定义好后，咱们能够在 API 中使用它，同时利用 Lambda 表达式。例如：

 //定义一个函数式接口
@FunctionalInterface
public interface WorkerInterface {

   public void doSomeWork();

}


public class WorkerInterfaceTest {

public static void execute(WorkerInterface worker) {
    worker.doSomeWork();
}

public static void main(String [] args) {

    //invoke doSomeWork using Annonymous class
    execute(new WorkerInterface() {
        @Override
        public void doSomeWork() {
            System.out.println("Worker invoked using Anonymous class");
        }
    });

    //invoke doSomeWork using Lambda expression 
    execute( () -> System.out.println("Worker invoked using Lambda expression") );
}

}

输出：

Worker invoked using Anonymous class 
Worker invoked using Lambda expression

这上面的例子里，咱们建立了自定义的函数式接口并与 Lambda 表达式一块儿使用。execute() 方法如今能够将 Lambda 表达式做为参数。

Lambda 表达式举例

学习 Lambda 表达式的最好方式是学习例子。

线程能够经过如下方法初始化：

//旧方法:
new Thread(new Runnable() {
@Override
public void run() {
    System.out.println("Hello from thread");
}
}).start();

//新方法:
new Thread(
() -> System.out.println("Hello from thread")
).start();

如下代码的做用是打印出给定数组中的全部元素。注意，使用 Lambda 表达式的方法不止一种。在下面的例子中，咱们先是用经常使用的箭头语法建立 Lambda 表达式，以后，使用 Java 8 全新的双冒号(::)操做符将一个常规方法转化为 Lambda 表达式：

//Old way:
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
for(Integer n: list) {
   System.out.println(n);
}

//New way:
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
list.forEach(n -> System.out.println(n));


//or we can use :: double colon operator in Java 8
list.forEach(System.out::println);