Java8新特性一:LambdaExpressions

编程

Lambda表达式

匿名类存在的问题是: 如果匿名类的实现非常简单,例如仅包含一个方法的接口,则匿名类的语法可能看起来很笨拙且不清楚。在这些情况下,您通常 new一个匿名内部类对象作为参数传递给方法,例如,当某人单击按钮时应采取什么措施。Lambda表达式 能实现这样的需求,它可以更紧凑更简洁的表达单方法类的实例。

本篇文章从以下几点介绍一下Lambda表达式:

  1. Lambda表达式用例

    • 搜索匹配一个特征的用户
    • 更通用的搜索方法
    • 在类中指定搜索条件
    • 在匿名类中指定搜索条件
    • 使用Lambda表达式指定搜索条件
    • 将functional interface与Lambda表达式一起使用
    • 更广泛的使用Lambda表达式

  2. Lambda表达式的语法
  3. 访问局部变量
  4. 目标类型

Lambda表达式的用例

假设您正在开发一个社交网络程序。您想新增一个功能,使管理员可以对满足特定条件的社交网络用户执行任何类型的操作,例如发送消息。

用户用以下Person类表示:

public class Person {

public enum Sex {

MALE, FEMALE

}

String name;

LocalDate birthday;

Sex gender;

String emailAddress;

public int getAge() {

// ...

}

public void printPerson() {

// ...

}

}

并且用户存储在一个List<Person>实例中。

我们先从最笨的实现开始,然后使用本地和匿名类对该方法进行改进,最后再使用lambda表达式以一种高效而简洁的方式实现。

搜索匹配一个特定特征的用户

一种简单的实现是:创建几个方法,每个方法都会搜索和一个特征(例如性别或年龄)相匹配的成员。以下方法将打印出超过指定年龄的成员:

public static void printPersonsOlderThan(List<Person> roster, int age) {

for (Person p : roster) {

if (p.getAge() >= age) {

p.printPerson();

}

}

}

这样做可以满足业务需求,但是他的可扩展性非常差,并且每个特征的一种搜索需要写一个方法,很麻烦。可以考虑以下几个问题:

  1. 类的属性有100个甚至1000个呢?
  2. 如果要打印小于的顶年龄的成员呢?

更通用的搜索方法

以下方法比前面的 printPersonsOlderThan方法更通用,它会打印指定年龄范围内的成员:

public static void printPersonsWithinAgeRange(List<Person> roster, int low, int high) {

for (Person p : roster) {

if (low <= p.getAge() && p.getAge() < high) {

p.printPerson();

}

}

}

考虑以下几个问题:

  1. 如果要打印指定性别或指定性别和年龄范围的组合,该怎么办?
  2. 如果您决定更改Person班级并添加其他属性,例如关系状态或地理位置,该怎么办?
  3. 尽管此方法比上面的printPersonsOlderThan通用,但尝试为每个特征创建单独的方法仍会导致代码脆弱。

在类中指定搜索条件

下面的方法打印和指定的搜索条件匹配的用户:

public static void printPersons(List<Person> roster, CheckPerson tester) {

for (Person p : roster) {

if (tester.test(p)) {

p.printPerson();

}

}

}

这个方法会遍历List中的Person对象,通过CheckPerson检查每个Person,如果满足搜索条件,就会输出Person信息。

要指定搜索条件,实现以下 CheckPerson接口:

interface CheckPerson {

boolean test(Person p);

}

下面的类实现了CheckPerson接口并且实现了接口中的test的方法,这个方法筛选男性且年龄在18至25岁之间的用户。

class CheckPersonEligibleForSelectiveService implements CheckPerson {

public boolean test(Person p) {

return p.gender == Person.Sex.MALE &&

p.getAge() >= 18 &&

p.getAge() <= 25;

}

}

使用CheckPerson

printPersons(

roster, new CheckPersonEligibleForSelectiveService());

在匿名类中指定搜索条件

以下方法传入的第二个参数是一个匿名类,该类筛选男性且年龄在18至25岁之间的用户:

printPersons(

roster,

new CheckPerson() {

public boolean test(Person p) {

return p.getGender() == Person.Sex.MALE

&& p.getAge() >= 18

&& p.getAge() <= 25;

}

}

);

这种方法减少了代码量,因为您不必为每个搜索条件创建一个类。但是,考虑到CheckPerson接口仅包含一个方法,并且匿名类的代码相当庞大,在这种情况下,您可以使用lambda表达式代替匿名类。

使用Lambda表达式指定搜索条件

CheckPerson 接口是一个functional interfacefunctional interface是仅包含一个抽象方法的接口 。(functional interface可能包含一个或多个 默认方法静态方法。)由于functional interface仅包含一个抽象方法,因此在实现该方法时可以省略该方法的名称。因此,可以使用lambda表达式(而不是使用匿名类表达式)。

printPersons(

roster,

(Person p) -> p.getGender() == Person.Sex.MALE

&& p.getAge() >= 18

&& p.getAge() <= 25

);

可以使用functional interface来代替CheckPerson,这可以进一步减少所需的代码量。

将functional interface与Lambda表达式一起使用

interface CheckPerson {

boolean test(Person p);

}

CheckPerson一个非常简单的接口,是一个functional interface。因为JDK已经提供了一些通用的functional interface,可以在java.util.function包中找到它们。所以,我们可以直接使用这些functional interface,如果能够满足我们的需求,我们没必要再定义这样的接口。

例如,可以使用 Predicate<T> 接口代替CheckPerson。该接口包含方法boolean test(T t)

interface Predicate<T> {

boolean test(T t);

}

此接口仅包含一个参数类型T。当使用实际参数声明或实例化泛型类型时,您将拥有一个参数化类型。例如,参数化类型Predicate<Person>如下:

interface Predicate<Person> {

boolean test(Person t);

}

此参数化类型包含一个方法,该方法的参数和返回类型与CheckPerson.boolean test(Person p)相同。因此,可以用Predicate<T>代替CheckPerson

public static void printPersonsWithPredicate(

List<Person> roster, Predicate<Person> tester) {

for (Person p : roster) {

if (tester.test(p)) {

p.printPerson();

}

}

}

因此,以下方法调用和在类中指定搜索条件有相同的效果:

printPersonsWithPredicate(

roster,

p -> p.getGender() == Person.Sex.MALE

&& p.getAge() >= 18

&& p.getAge() <= 25

);

这不是使用lambda表达式的唯一方式。

更广泛的使用Lambda表达式

重新看一下printPersonsWithPredicate方法,看看在什么地方还可以使用lambda表达式:

public static void printPersonsWithPredicate(

List<Person> roster, Predicate<Person> tester) {

for (Person p : roster) {

if (tester.test(p)) {

p.printPerson();

}

}

}

我们接下来将printPerson方法用Lambda表达式代替,那么我们需要一个functional interface,该方法可以传入一个Person类型的参数并返回void。 很幸运,JDK提供的 Consumer<T> 接口满足这样的需求。

public static void processPersons(

List<Person> roster,

Predicate<Person> tester,

Consumer<Person> block) {

for (Person p : roster) {

if (tester.test(p)) {

block.accept(p);

}

}

}

调用该方法时的写法如下:

processPersons(

roster,

p -> p.getGender() == Person.Sex.MALE

&& p.getAge() >= 18

&& p.getAge() <= 25,

p -> p.printPerson()

);

如果想对个人资料进行更多处理而不仅仅打印出来,该怎么办?假设要验证用户的个人资料或检索他们的联系信息?在这种情况下,需要一个functional interface,其中包含一个有返回值的抽象方法。很幸运,JDK提供的 Function<T,R> 接口接口满足这样的需求。

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

}

}

}

以下调用先从符合条件的Person中获取电子邮件信息,然后打印出来:

processPersonsWithFunction(

roster,

p -> p.getGender() == Person.Sex.MALE

&& p.getAge() >= 18

&& p.getAge() <= 25,

p -> p.getEmailAddress(),

email -> System.out.println(email)

);

Lambda表达式的语法

Lambda表达式包含以下内容:

  1. 参数以逗号分隔,用括号括起来。CheckPerson.test方法包含一个参数p, 它代表Person类的一个实例。

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

p-> p.getGender()== Person.Sex.MALE 

&& p.getAge()> = 18

&& p.getAge()<= 25

  1. 箭头标记 ->

  2. 由单个表达式或语句块组成。本示例使用以下表达式:

p.getGender()== Person.Sex.MALE 

&& p.getAge()> = 18

&& p.getAge()<= 25

如果指定单个表达式,将计算表达式并返回其值。另外,可以使用return语句:

p -> {

return p.getGender() == Person.Sex.MALE

&& p.getAge() >= 18

&& p.getAge() <= 25;

}

return语句不是表达式。在lambda表达式中,必须将语句括在大括号{}中。但是,对void方法的调用不用括在大括号中。例如,以下是有效的lambda表达式:

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

}

}

该方法operateBinary对两个整数进行数学运算。由IntegerMath的具体实现来计算。示例中定义了两个Lambda表达式:additionsubtraction。示例输出以下内容:

40 + 2 = 42

20-10 = 10

访问局部变量

像本地和匿名类一样,lambda表达式可以访问变量。它们对局部变量具有相同的访问权限。

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

}

}

本示例输出:

x = 23

y = 23

this.x = 1

LambdaScopeTest.this.x = 0

如果在myConsumer声明里用参数x代替y,编译器将报错:

Consumer<Integer> myConsumer = (x) -> {

// ...

}

错误信息:methodInFirstLevel(int)方法已经定义了变量x 。这是因为lambda表达式未引入新的作用域级别。因此,您可以直接访问该范围的字段、方法和局部变量。例如,lambda表达式直接访问methodInFirstLevel方法的x参数。要访问类中的变量,请使用关键字this。在此示例中,this.x引用成员变量FirstLevel.x。

与本地和匿名类一样,lambda表达式只能访问用final或effectively final的局部变量和参数。例如,假设您在methodInFirstLevel方法内部添加以下赋值语句:

void methodInFirstLevel(int x){

x = 99;

// ...

}

由于改变了x的值,所以该变量不再是final或实际上final类型的变量。由于lambda表达式myConsumer会访问FirstLevel.x变量,结果Java编译器报一条错误信息,类似于lambda表达式引用的本地变量必须是final或实际上是final。

System.out.println(“ x =” + x);

目标类型

您如何确定Lambda表达式的类型?回忆一下选择年龄在18至25岁之间的男性用户的lambda表达式:

p -> p.getGender() == Person.Sex.MALE

&& p.getAge() >= 18

&& p.getAge() <= 25

此lambda表达式用在以下两个方法:

public static void printPersons(List<Person> roster, CheckPerson tester)

public void printPersonsWithPredicate(List<Person> roster, Predicate<Person> tester)

当调用printPersons方法时,它期望的数据类型为CheckPerson,因此lambda表达式为该类型。但是,当调用printPersonsWithPredicate方法时,它期望的数据类型为Predicate<Person>,因此lambda表达式就是这种类型。

这些方法期望的数据类型称为目标类型。

关注:Java提升营

→「技术干货」每日推送

→「2T免费资料」随时领取

以上是 Java8新特性一:LambdaExpressions 的全部内容, 来源链接: utcz.com/z/515478.html

回到顶部