Lambda 表达式

Lambda 表达式

想要更好的了解Lambda,请先了解匿名类, 匿名类通常比命名类更简洁,但对于只有一个方法的类,即使是匿名类也似乎有点繁琐,Lambda表达式允许更紧凑地表达单方法类的实例。
我们接下来一步步的来了解Lambda。

首先我们有一个Person类

import java.util.List;
import java.util.ArrayList;
import java.time.chrono.IsoChronology;
import java.time.LocalDate;

public class Person {

    public enum Sex {
        MALE, FEMALE
    }

    String name;
    LocalDate birthday;
    Sex gender;
    String emailAddress;

    Person(String nameArg, LocalDate birthdayArg,
           Sex genderArg, String emailArg) {
        name = nameArg;
        birthday = birthdayArg;
        gender = genderArg;
        emailAddress = emailArg;
    }

    public int getAge() {
        return birthday
                .until(IsoChronology.INSTANCE.dateNow())
                .getYears();
    }

    public void printPerson() {
        System.out.println(name + ", " + this.getAge());
    }

    public Sex getGender() {
        return gender;
    }

    public String getName() {
        return name;
    }

    public String getEmailAddress() {
        return emailAddress;
    }

    public LocalDate getBirthday() {
        return birthday;
    }

    public static int compareByAge(Person a, Person b) {
        return a.birthday.compareTo(b.birthday);
    }

    public static List createRoster() {

        List roster = new ArrayList<>();
        roster.add(
                new Person(
                        "Fred",
                        IsoChronology.INSTANCE.date(1980, 6, 20),
                        Person.Sex.MALE,
                        "[email protected]"));
        roster.add(
                new Person(
                        "Jane",
                        IsoChronology.INSTANCE.date(1990, 7, 15),
                        Person.Sex.FEMALE, "[email protected]"));
        roster.add(
                new Person(
                        "George",
                        IsoChronology.INSTANCE.date(1991, 8, 13),
                        Person.Sex.MALE, "[email protected]"));
        roster.add(
                new Person(
                        "Bob",
                        IsoChronology.INSTANCE.date(2000, 9, 12),
                        Person.Sex.MALE, "[email protected]"));

        return roster;
    }
}

我们先用这个简单的案例,然后逐步使用lambda表达式来完成示例的学习,该示例代码参考RosterTest

方法1:搜索年龄大于age的人员

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

方法2:搜索年龄在一个区间范围的人员

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

如果你想要打印指定性别的成员,或指定性别和年龄范围的组合,该怎么办? 如果您决定更改Person类并添加其他属性(如关系状态或地理位置),该怎么办? 显然为每个可能的搜索查询创建单独的方法会导致很多臃肿的代码。 如果你学过设计模式的话,策略模式是比较适合这种情况的。

方法3:使用策略模式

1、UML图


Lambda 表达式_第1张图片
Strategy

2、接口

interface CheckPerson {
    boolean test(Person p);
}

3、策略实现

CheckPersonEligibleForSelectiveService
class CheckPersonEligibleForSelectiveService implements CheckPerson {
    public boolean test(Person p) {
        return p.gender == Person.Sex.MALE &&
            p.getAge() >= 18 &&
            p.getAge() <= 25;
    }
}

4、caller

public static void printPersons(
    List roster, CheckPerson tester) {
    for (Person p : roster) {
        if (tester.test(p)) {
            p.printPerson();
        }
    }
}

5、测试

printPersons(roster, new CheckPersonEligibleForSelectiveService());

方法4:使用匿名类

方法3,可以依据条件随时定义新的策略,看起来应该都满足开闭原则,也能随时满足不断变化的需求了,但是代码似乎有点臃肿,那么匿名类似乎不用定义一个新的类了。

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

是不是简洁了许多

方法5:使用Lambda表达式

接口CheckPerson是一个 functional interface。 functional interface的定义是:接口包含且只包含一个抽象方法(functional interface可以包含一个或多个 default 方法 or static 方法.)
这种类型的接口也称为SAM接口,即Single Abstract Method interfaces。
由于functional interface只包含一个抽象方法,因此在实现该方法时可以省略该方法的名称。 因此, 我们可以使用 lambda expression代替匿名类,如下所示:

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

方法6:使用通用接口并使用Lambda表达式

我们回过头来再看一眼CheckPerson接口

interface CheckPerson {
    boolean test(Person p);
}

这是一个非常简单的接口,这个接口仅仅包含了一个抽象方法,该方法接受一个参数,并返回一个布尔值。在应用程序中定义一个这个的接口并不值得。因此JDK在java.util.function包中定义了若干个标准的接口。
我们可以使用java.util.function.Predicate替代CheckPerson,该接口包含一个boolean test(T t)方法

interface Predicate {
    boolean test(T t);
}

因此,以下方法调用和方法3调用printPersons是一样的效果

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

这不是lambda表达式的唯一的使用方式。下面我们将解锁lambda表达式的其他姿势。

方法7:在整个函数中使用Lambda表达式

我们再回头查看printPersonsWithPredicate,看看其他地方是否也可以使用lambda表达式呢:

public static void printPersonsWithPredicate(
    List roster, Predicate tester) {
    for (Person p : roster) {
        if (tester.test(p)) {
            p.printPerson();
        }
    }
}

此方法是检查Person集合中的实例是否满足Predicate中的条件。如果Person实例满足tester指定的条件,则在Person实例上调用printPersron方法。
我们如果想要再满足tester条件下,执行不同的操作,而不仅仅是调用printPersron方法,那么我们可以使用新的lambda表达式。如果要使用lambda表达式,需要创建一个functional interface,该函数接口包含一个Person类型的参数,并返回一个void类型。而jdk java.util.functionConsumer已经帮我们实现了这样的接口,我们使用便是,Consumer 包含一个 void accept(T t)方法,符合的要求,下面我们将p.printPerson()替换为Consumeraccept方法.

public static void processPersons(
    List roster,
    Predicate tester,
    Consumer block) {
        for (Person p : roster) {
            if (tester.test(p)) {
                block.accept(p);
            }
        }
}

因此,我们调用该方法和方法3一样,如下所示:

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

看起来我们已经很完美的解决了一些问题,那么新的需求又来了,讨厌的产品经理总是不让人省心一点,他不要求打印Person了,要求如果通过验证了,打印Person的其他信息。幸好jdk的java.util.function.Function帮我们写好了相关的函数接口,Function包含一个R apply(T t)方法,该方法指定一个mapper参数,然后返回mapper加工后的数据,然后调用Consumer block消费R值。如下所示:

public static void processPersonsWithFunction(
    List roster,
    Predicate tester,
    Function mapper,
    Consumer block) {
    for (Person p : roster) {
        if (tester.test(p)) {
            String data = mapper.apply(p);
            block.accept(data);
        }
    }
}

调用方式如下,我们获取人员的Email联系信息,然后将联系方式打印出来

processPersonsWithFunction(
    roster,
    p -> p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25,
    p -> p.getEmailAddress(),
    email -> System.out.println(email)
);

方法8:更广泛地使用泛型

我们再次改造一下processPersonsWithFunction,将参数类型变成更加通用的泛型,可以接受任何类型的参数,而不仅仅是Person。如下所示:

public static  void processElements(
    Iterable source,
    Predicate tester,
    Function  mapper,
    Consumer 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)
);

该方法调用执行如下操作:
1、从集合中获取元素。该事例中表示的是Person对象的List集合。请注意:List类型的集合是Iterable类型的子类。
2、使用Predicate对象过滤Person对象。在此示例中,Predicate对象是一个lambda表达式,匹配相关对象是否符合条件。
3、将每个过滤出来的对象传递赋值到Function mapper对象,在此示例中,Function对象是一个lambda表达式,它返回Person的email属性。
4、对Consumer对象进行消费操作。 在此示例中,Consumer对象是一个lambda表达式,用于输出字符串,该字符串是Function对象返回的email值。
你可以使用聚合操作替换每一个操作。

方法9:使用Lambda表达式作为聚合操作的参数

使用聚合操作来打印集合中符合条件的Person的email地址,如下所示:

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

下表将方法processElements执行的每个操作映射到相应的聚合操作:

processElements 操作 聚合操作
获取集合对象 Stream stream()
Predicate 对象过滤器 Stream filter(Predicate predicate)
*Function *将对象转化为其他值 Stream map(Function mapper)
*Consumer *消费对象 void forEach(Consumer action)

filter, map,forEach都属于聚合操作,聚合操作处理流中的元素,而不是直接从集合中获取元素。流是元素的一个序列,不同于集合,它不是存储元素的数据结构。流通过管道携带来自源(例如集合)的值。 管道是一系列流操作,在此示例中为filter-map-forEach。 此外,聚合操作通常接受lambda表达式作为参数,你也可以自定义聚合操作。
该章节主要论述lamabda表达式,以后会更加深入的讲解stream的相关知识。

Lambda 表达式在GUI应用中的使用

在 GUI 应用程序中的事件(例如键盘操作,鼠标操作和滚动操作),通常会创建事件处理程序,这通常涉及实现特定接口。 通常,事件处理程序接口是functional interfaces; 他们往往只有一种方法。
在示例HelloWorld.java 中的原来使用的匿名内部类,我们可以使用lamabda替代。

          btn.setOnAction(new EventHandler() {

            @Override
            public void handle(ActionEvent event) {
                System.out.println("Hello World!");
            }
        });

方法btn.setOnAction的参数EventHandler的作用是指定响应方法,该 EventHandler接口只包含一个void handle(T event)方法,那么该接口就属于一个functional interface,所以我们可以使用下面的lambda表达式替代它:

        btn.setOnAction(
          event -> System.out.println("Hello World!")
        );

Lambda表达式的语法

lambda表达式包含以下内容:

  • 括号中用逗号分隔的形式参数列表。 CheckPerson.test方法包含一个参数p,它表示Person类的实例。

Note: 你可以省略lambda表达式中参数的数据类型。 此外,如果只有一个参数,则括号也可以省略。 例如,以下lambda表达式也是有效的:

p -> p.getGender() == Person.Sex.MALE 
    && p.getAge() >= 18
    && p.getAge() <= 25
  • 箭头标记,->
  • 一个body,由单个表达式或语句块组成。 此示例使用以下表达式:
p.getGender() == Person.Sex.MALE 
    && p.getAge() >= 18
    && p.getAge() <= 25

如果指定单个表达式,则Java将计算表达式,然后返回其值。 或者,您可以使用return语句:

p -> {
    return p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25;
}

return语句不是表达式; 在lambda表达式中,必须将语句括在大括号({})中。 但是,没必要在大括号中包含只有一条void方法调用。 例如,以下是有效的lambda表达式:

email -> System.out.println(email)

Note: lambda表达式看起来很像方法声明; 您可以将lambda表达式视为匿名方法 - 没有名称的方法。

下面的示例Calculator.java 是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));    
    }
}

方法operateBinary对两个整数执行数学运算操作。 操作本身由IntegerMath实例指定。 该示例使用lambda表达式定义了两个操作,加法和减法。 该示例打印内容如下:

40 + 2 = 42
20 - 10 = 10

局部变量的访问界限

Shadowing

如果特定范围(例如内部类或方法定义)中的类型声明(例如成员变量或参数名称)与封闭范围中的另一个声明具有相同的名称,则声明将隐藏声明封闭范围。 你不能仅通过其名称引用带Shadowing的声明。 以下ShadowTest.java示例说明了这一点:

public class ShadowTest {

    public int x = 0;

    class FirstLevel {

        public int x = 1;

        void methodInFirstLevel(int x) {
            System.out.println("x = " + x);
            System.out.println("this.x = " + this.x);
            System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
        }
    }

    public static void main(String... args) {
        ShadowTest st = new ShadowTest();
        ShadowTest.FirstLevel fl = st.new FirstLevel();
        fl.methodInFirstLevel(23);
    }
}

输出如下:

x = 23
this.x = 1
ShadowTest.this.x = 0

此示例定义了三个名为x的变量:类ShadowTest的成员变量,内部类FirstLevel的成员变量,以及methodInFirstLevel方法中的参数。 方法methodInFirstLevel的参数变量x,隐藏了内部类FirstLevel的变量。 因此,当你在方法methodInFirstLevel中使用变量x时,它引用的是方法参数。 要引用内部类FirstLevel的成员变量,需要使用关键字this来确认范围:

System.out.println("this.x = " + this.x);

关于更大范围的外部类的成员变量,如果要在方法methodInFirstLevel中访问的话,需要使用如下语句:

System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);

和本地和匿名类一样,lambda表达式也可以捕获变量; 它们对封闭范围的局部变量具有相同的访问权限。 但是,与本地和匿名类不同,lambda表达式没有任何Shadowing问题。 Lambda表达式是词法范围的。意思是Lambda表达式中声明的参数变量不是从父类中继承的,也不会引入新的一个范围(很拗口,直接看代码吧),lambda表达式中的声明与封闭环境中的声明一样被识别。下面的LambdaScopeTest说明了这一点。

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 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);
    }
}

输出如下:

x = 23
y = 23
this.x = 1
LambdaScopeTest.this.x = 0

如果在lambda表达式myConsumer的声明中用参数x代替y,会发生什么呢?:

Consumer myConsumer = (x) -> {
    // ...
}

编译器会报错:"variable x is already defined in method methodInFirstLevel(int)",因为lambda表达式不会引入新的范围。因此,你可以直接访问封闭范围的字段,方法和局部变量。 例如,lambda表达式直接访问methodInFirstLevel方法的参数x。如果要访问内部类中的变量,需要使用关键字this。 在此示例中,this.x引用成员变量FirstLevel.x

与本地和匿名类一样,lambda表达式访问局部变量和参数只能属于final类型的。 例如,假设在methodInFirstLevel语句之后立即添加以下赋值语句:

void methodInFirstLevel(int x) {
    x = 99;
    // ...
}

因为x=99这条赋值语句,变量FirstLevel.x就不再是effectively final的了,结果就是,编译器会再如下语句的位置(lambda表达式myConsumer尝试访问FirstLevel.x变量:),抛出error--"local variables referenced from a lambda expression must be final or effectively final".

System.out.println("x = " + x);

目标类型确定

如何确定lambda表达式的类型?我们回顾一下上面得例子:

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

这个表达式在下面两个地方用到了:

  • public static void printPersons(List roster, CheckPerson tester) #方法3

  • public void printPersonsWithPredicate(List roster, Predicate tester) #方法6

当虚拟机调用printPersons方法时,它期望CheckPerson的数据类型,因此lambda表达式属于这种类型。但是,当调用方法printPersonsWithPredicate时,它期望数据类型为Predicate ,因此lambda表达式属于此类型。这些方法所期望的数据类型称为目标类型。Java编译器根据lambda表达式的上下文或场合的确定lambda表达式的目标类型。因此,只能在Java编译器可以确定目标类型的情况下使用lambda表达式:

  • 变量声明
  • 赋值声明
  • 返回声明
  • 数组初始化
  • 方法参数或构造函数参数
  • Lambda表达体
  • 条件表达式,?:
  • 转换表达式

目标类型和方法参数

对于方法参数,Java编译器使用两种语言特性确定目标类型:重载解析和类型参数推断。
例如以下两个功能接口(java.lang.Runnablejava.util.concurrent.Callable ):

public interface Runnable {
    void run();
}

public interface Callable {
    V call();
}

方法Runnable.run没有返回值,而Callable .call则有返回值。
假设您已按如下方式重载方法调用:

void invoke(Runnable r) {
    r.run();
}

 T invoke(Callable c) {
    return c.call();
}

那么下面得语句将会调用那个方法呢?

String s = invoke(() -> "done");

方法invoke(Callable)将会被调用。在这种情况下,lambda表达式() -> "done"返回 "done"字符串,所以根据返回值推导,目标类型为Callable.

你可能感兴趣的:(Lambda 表达式)