Java 8中的Lambda表达式（基于Java 8 Tutorial）

参考地址：http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

本文档下载地址：点击打开链接

说明：主要讲解java 8中的Lambda表达式，还有一些functional interface的内容。内容完全基于java 8 tutorial，加上一些自己的注释与理解。

使用代码本身来进行解释（这是java 8 tutorial中的风格），同时去掉一些无关紧要的知识点（比如泛型等），并且增加了一些自己的必要的注释，

相信更易于大家理解。

作者：zhrb from jmu

注意：

1.页面查看效果很差，还是下载word附件进行查看。

2.在word中打开“导航窗格”或”文档结构图”更方便查看。

Lambda Expressions

应用背景：现在希望对List<Person> roster中符合条件的Person进行一些操作，比如输出姓名等..

 Approach 1: Create Methods That Search forMembers That Match One Characteristic

public static void printPersonsOlderThan(List<Person> roster, int age) {
    for (Person p : roster) {
        if (p.getAge() >= age) {
            p.printPerson();
        }
    }
}

Approach 2: Create More Generalized SearchMethods

public static void printPersonsWithinAgeRange(
    List<Person> roster, int low, int high) {
    for (Person p : roster) {
        if (low <= p.getAge() && p.getAge() < high) {
            p.printPerson();
        }
    }
}

Approach 3: Specify Search Criteria Code ina Local Class

public static void printPersons(
    List<Person> roster, CheckPerson tester) {
    for (Person p : roster) {
        if (tester.test(p)) {
            p.printPerson();
        }
    }
}
interface CheckPerson {
    boolean test(Person p);
}
class CheckPersonEligibleForSelectiveService implements CheckPerson {
    public boolean test(Person p) {
        return p.gender == Person.Sex.MALE &&
            p.getAge() >= 18 &&
            p.getAge() <= 25;
    }
}

使用：printPersons(roster, new CheckPersonEligibleForSelectiveService());

Approach 4: Specify Search Criteria Code inan Anonymous Class

printPersons(
    roster,
    new CheckPerson() {
        public boolean test(Person p) {
            return p.getGender() == Person.Sex.MALE
                && p.getAge() >= 18
                && p.getAge() <= 25;
        }
    }
);

Approach 5: Specify Search Criteria Codewith a Lambda Expression

printPersons(
    roster,
    (Person p) -> p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25
);

Approach 6: Use Standard FunctionalInterfaces with Lambda Expressions

interface CheckPerson {
    boolean test(Person p);
}
interface Predicate<T> {//functional interface
    boolean test(T t);
}

可以看出CheckPerson接口与Predicate<T>接口中定义的方法，都是传递进一个类型，返回boolean，形式上基本一致。

我们现在使用Predicate<T>接口取代CheckPerson接口(好处：少写一个接口，直接用通用接口)修改代码如下：

方法定义

public static void printPersonsWithPredicate(
    List<Person> roster, Predicate<Person> tester) {
    for (Person p : roster) {
        if (tester.test(p)) {
            p.printPerson();
        }
    }//使用匿名内部类
}

不需要再自定义一个CheckPerson接口，直接使用Predicate<Person>即可。

方法调用：

printPersonsWithPredicate(
    roster,
    p -> p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25
);

Approach 7: Use Lambda ExpressionsThroughout Your Application

<pre code_snippet_id="315621" snippet_file_name="blog_20140427_9_7239644" name="code" class="java">
public static void printPersonsWithPredicate(
    List<Person> roster, Predicate<Person> tester) {
    for (Person p : roster) {
        if (tester.test(p)) {
            p.printPerson();
        }
    }
}

上面的所有代码，对符合条件的Person只能print，如果需要进行更多的操作，怎么办？

方法定义：

public static void processPersons(
    List<Person> roster,
    Predicate<Person> tester,
    Consumer<Person> block) {
        for (Person p : roster) {
            if (tester.test(p)) {
                block.accept(p);//一个没有返回值的操作
            }
        }
}
</pre>
其中Consumer<Person>也是jdk中的functional interface，有一个方法void accept(T t)，这个方法的特点刚好和printPerson()一样，没有任何的返回值
(原理类似于Approach 6中讲的内容)。上述定义也适合任何没有返回值的操作，
改进的方法调用：
processPersons(
     roster,
     p -> p.getGender() == Person.Sex.MALE
         && p.getAge() >= 18
         && p.getAge() <= 25,
     p -> p.printPerson()//实际上，这行还可以换成其他操作
);
可以看到processPersons不仅可以printPerson还可以调用其他方法，只要该方法的形式符合void accept(T t)….即1.无返回值。2.接受一个类型的参数。
进一步的，如果不仅要对符合条件的person进行“一个没有返回值的操作”，如上面的block.accept(p)，还希望对他进行一些有返回值的操作，则可以使用Function<T,R>这个functional interface，该接口包含一个R apply(T t)，如定义Function<Person, String>，那么就包含一个String apply(Person p)这样的操作。也就是说可以对符合条件的用户，执行一些操作并返回一个String值。
修改的定义如下：
public static void processPersonsWithFunction(
    List<Person> roster,
    Predicate<Person> tester,
    Function<Person, String> mapper,
    Consumer<String> block) {
    for (Person p : roster) {
        if (tester.test(p)) {
            String data = mapper.apply(p);//有返回值的操作
            block.accept(data);//无返回值的操作
        }
    }
}
调用如下：
processPersonsWithFunction(
    roster,
    p -> p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25,
    p -> p.getEmailAddress(),//有返回值的操作
    email -> System.out.println(email) //无返回值的操作
);
<span style="background-color: rgb(255, 255, 255); font-family: Arial, Helvetica, sans-serif;">Approach 8: Use Generics More Extensively</span>
更通用的写法，比如下面这个函数，可以针对所有实现Iterable接口的实现类(如列表，数组)进行Predicate、Function与Consumer操作。不过通用是通用，但我觉得一般还是不要这么写。因为要有许多前期知识(如functional interface，泛型)才能看懂这个代码，降低代码的可阅读性。
方法定义：
public static <X, Y> void processElements(
    Iterable<X> source,
    Predicate<X> tester,
    Function <X, Y> mapper,
    Consumer<Y> block) {
    for (X p : source) {
        if (tester.test(p)) {
            Y data = mapper.apply(p);
            block.accept(data);
        }
    }
}
方法调用：
processElements(
    roster,
    p -> p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25,
    p -> p.getEmailAddress(),
    email -> System.out.println(email)
);
Approach 9: Use Aggregate Operations ThatAccept Lambda Expressions as Parameters
将Lambda当做参数…
roster.stream().filter(
        p -> p.getGender() == Person.Sex.MALE
            && p.getAge() >= 18
            && p.getAge() <= 25)
    .map(p -> p.getEmailAddress())
    .forEach(email -> System.out.println(email));
Lambda Expressions in GUI Applications
btn.setOnAction(new EventHandler<ActionEvent>() {//匿名类
 
            @Override
            public void handle(ActionEvent event) {
                System.out.println("Hello World!");
            }
        });
改进，使用Lambda
btn.setOnAction(
          event -> System.out.println("Hello World!")
        );
Syntax of Lambda Expressions
一个Lambda表达式由以下几部分构成：
1.A comma-separated list of formalparameters enclosed in parentheses.
一个用逗号分隔的形参列表，要用两个圆括号包起来。前面的例子，p就是形式参数，因为只有一个形参，所以不需要使用括号。不需要指定参数的类型，比如p。
 某Lambda表达式：
p -> p.getGender() == Person.Sex.MALE 
    && p.getAge() >= 18
    && p.getAge() <= 25
2.The arrow token, ->
右箭头
3. A body, which consists of a singleexpression or a statement block
比如上面的
p.getGender() == Person.Sex.MALE 
    && p.getAge() >= 18
    && p.getAge() <= 25
如果指定一个表达式，Java runtime计算该表达式然后返回其值。
还有另外一种定义法，使用一个return语句。
p -> {
    return p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25;
}
return语句不是表达式，在lambda表达式中，你必须使用{}把他括起来。不过你不用将一个返回值为void的方法括起来，比如：
email -> System.out.println(email)
lambda表达式看起来很像一个方法声明。你可以把lambda表达式当做一个匿名方法(没有名字的方法)。下面这个例子Calculator中，lambda表达式看起来不仅仅是一个形式参数。
public class Calculator {
    interface IntegerMath {
        int operation(int a, int b);   
    }
    public int operateBinary(int a, int b, IntegerMath op) {
        return op.operation(a, b);
    }
    public static void main(String... args) {
        Calculator myApp = new Calculator();
        IntegerMath addition = (a, b) -> a + b;
        IntegerMath subtraction = (a, b) -> a - b;
        System.out.println("40 + 2 = " +
            myApp.operateBinary(40, 2, addition));
        System.out.println("20 - 10 = " +
            myApp.operateBinary(20, 10, subtraction));    
    }
}
Accessing Local Variables of the Enclosing Scope
import java.util.function.Consumer;

public class LambdaScopeTest {
    public int x = 0;
    class FirstLevel {
        public int x = 1;
        void methodInFirstLevel(int x) {
            // The following statement causes the compiler to generate
            // the error "local variables referenced from a lambda expression
            // must be final or effectively final" in statement A:
            //
            // x = 99;
            
            Consumer<Integer> myConsumer = (y) -> 
            {
                System.out.println("x = " + x); // Statement A
                System.out.println("y = " + y);
                System.out.println("this.x = " + this.x);
                System.out.println("LambdaScopeTest.this.x = " +
                    LambdaScopeTest.this.x);
            };
            myConsumer.accept(x);
        }
    }
    public static void main(String... args) {
        LambdaScopeTest st = new LambdaScopeTest();
        LambdaScopeTest.FirstLevel fl = st.new FirstLevel();
        fl.methodInFirstLevel(23);
    }
}
This example generates the followingoutput:
x = 23
y = 23
this.x = 1
LambdaScopeTest.this.x = 0

1.首先看注释的那些语句，如x=99，和methodInFirstLevel(intx)相冲突，所以会引起编译错误。当然如果将x=99定义成final x =99，可能就没问题了
2.可以看到Lambda表达式中可以通过this.x访问所在类的x属性，还可以通过LambdaScopeTest.this.x访问外部类的x属性。
Target Typing
Lambda表达式类型如何确定？
比如下面的Lambda表达式
p -> p.getGender() == Person.Sex.MALE
    && p.getAge() >= 18
    && p.getAge() <= 25
在public staticvoid printPersons(List<Person> roster, CheckPerson tester)类型是CheckPerson
在public voidprintPersonsWithPredicate(List<Person> roster, Predicate<Person> tester)类型是Predicate<Person>
也就是说所期望的类型(CheckPerson、Predicate<Person>)叫做target type。
Java编译器可以通过target type的使用上下文或lambda表达式被找到的所在地来决定lambda表达式的类型。
Target Types and Method Arguments
对于方法参数，Java编译器使用其他两种语言特性来决定target type。
这两种语言特性是：1.overload resolution 2.type argument inference
如
public interface Runnable {
    void run();
}
public interface Callable<V> {
    V call();
}
可以看到两种方法返回值不同，假设我们定义了两个重载方法invoke方法
void invoke(Runnable r) {
    r.run();
}
<T> T invoke(Callable<T> c) {
    return c.call();
}
那么，如果String s = invoke(() -> "done");调用的是哪一个invoke方法呢？
这个我就不说了，大家自己应该能猜出来。
 
Serialization
可以序列化一个lambda表达式，但是强烈建议大家不要序列化lambda表达式。