Java编程中使用lambda表达式的奇技淫巧

2024-03-20 18:34:02 338

为什么使用Lambda表达式
先看几个例子：

第一个例子，在一个独立的线程中执行某项任务，我们通常这么实现：

classWorkerimplementsRunnable{
publicvoidrun(){
for(inti=0;i<100;i++)
doWork();
}
...
}

Workerw=newWorker();
newThread(w).start();

第二个例子，自定义字符串比较的方法（通过字符串长度），一般这么做：

classLengthComparatorimplementsComparator<String>{
publicintcompare(Stringfirst,Stringsecond){
returnInteger.compare(first.length(),second.length());
}
}
Arrays.sort(strings,newLengthComparator());

第三个例子，在JavaFX中，给一个button添加一个callback：

button.setOnAction(newEventHandler<ActionEvent>(){
publicvoidhandle(ActionEventevent){
System.out.println("Thanksforclicking!");
}
});

这些例子有一个共同点，就是：先定义一段代码块，传给某个对象或方法，然后被执行。在Lambda表
达式之前，Java是不允许直接传递代码块的，因为Java是面向对象的，因此必须传递一个对象，将要
执行的代码块封装到对象里。

Lambda表达式的语法
将上面第二个例子中的LengthComparator，用Lambda表达式表示为：

(Stringfirst,Stringsecond)->Integer.compare(first.length(),
second.length());

->前为参数列表，其后为表达式语句体；

如果表达式语句体不止一行，则将语句体写在{}中，与普通的函数一样：

(Stringfirst,Stringsecond)->{
if(first.length()>second.length()){
return1;
}elseif(first.length()==second.length()){
return0;
}else{
return-1;
}
};

如果没有参数，()还是需要带上，比如上面的第一个例子，可以表示为：

()->{
for(inti=0;i<1000;i++){
doWork();
}
}

如果参数的类型可以从上下文自动推断，则可以省略：

Comparator<String>comp
=(first,second)//Sameas(Stringfirst,Stringsecond)
->Integer.compare(first.length(),second.length());

如果参数只有一个，且类型可以自动推断，则小括号()也可以省略：

//Insteadof(event)->or(ActionEventevent)->
eventHandler<ActionEvent>listener=
event->System.out.println("Thanksforclicking!");

lambda表达式的返回值的类型是自动推断的，因此不需要指明；在lambda表达式，某些条件分支中有
返回值，而其它分支没有返回值，是不允许的，如：

(x)->{
if(x>=0){
return1;
}
}

另外，expressionlambda和statementlambda的区别是，expressionlambda不需要
写return关键字，Javaruntime会将表达式的结果作为返回值返回，而statementlambda是
写在{}中的表达式，需要使用return关键字，比如：

//expressionlambda
Comparator<String>comp1=
(first,second)->Integer.compare(first.length(),second.length());

//statementlambda
Comparator<String>comp2=(first,second)->
{returnInteger.compare(first.length(),second.length());};

FunctionalInterface
如果一个接口（interface）仅有一个抽象方法（abstractmethod），就称为
FunctionalInterface，比如Runnable、Comparator等。
在任何一个需要FunctionalInterface对象的地方，都可以使用lambda表达式：

Arrays.sort(words,
(first,second)->Integer.compare(first.length(),second.length()));

这里，sort()的第二个参数需要的是一个Comparator对象，而Comparator是
FunctionalInterface，因此可以直接传入lambda表达式，在调用该对象的compare()方法
时，就是执行该lambda表达式中的语句体；

如果lambda表达式的语句体会抛出异常，则对应的FunctionalInterface中的抽象方法必须抛
出了该异常，否则就需要在lambda表达式中显式捕获异常：

Runnabler=()->{
System.out.println("------");
try{
Thread.sleep(10);
}catch(InterruptedExceptione){
//catchexception
}
};

Callable<String>c=()->{
System.out.println("--------");
Thread.sleep(10);
return"";
};

MethodReference
如果将lambda表达式的参数作为参数传递给一个方法，他们的执行效果是相同的，则该lambda表达式
可以使用MethodReference表达，以下两种方式是等价的：

(x)->System.out.println(x)
System.out::println

其中System.out::println被称为MethodReference。

MethodReference主要有三种形式：

object::instanceMethod
Class::staticMethod
Class::instanceMethod

对于前两种方式，对应的lambda表达式的参数和method的参数是一致的，比如：

System.out::println
(x)->System.out.println(x)

Math::pow
(x,y)->Math.pow(x,y)

对于第三种方式，对应的lambda表达式的语句体中，第一个参数作为对象，调用method，将其它参数
作为method的参数，比如：

String::compareToIgnoreCase
(s1,s2)->s1.compareToIgnoreCase(s2)
1.5ConstructorReference

ConstructorReference与MethodReference类似，只不过是特殊的method：new，具体调用的是哪个构造函数，由上下文环境决定，比如：

List<String>labels=...;
Stream<Button>stream=labels.stream().map(Button::new);

Button::new等价于(x)->Button(x)，所以调用的构造函数是：Button(x);

除了创建单个对象，也可以创建对象数组，如下面两种方式等价：

int[]::new
(x)->newint[x]

变量作用域
lambd表达式会捕获当前作用域下可用的变量，比如：

publicvoidrepeatMessage(Stringtext,intcount){
Runnabler=()->{
for(inti=0;i<count;i++){
System.out.println(text);
Thread.yield();
}
};
newThread(r).start();
}

但是这些变量必须是不可变的，为什么呢？看下面这个例子：

intmatches=0;
for(Pathp:files)
newThread(()->{if(phassomeproperty)matches++;}).start();
//Illegaltomutatematches

因为可变的变量在lambda表达式中不是线程安全的，这和内部类的要求是一致的，内部类中只能引用
外部定义的final变量；

lambda表达式的作用域与嵌套代码块的作用域是一样的，所以在lambd表达式中的参数名或变量名不
能与局部变量冲突，如：

Pathfirst=Paths.get("/usr/bin");
Comparator<String>comp=(first,second)->Integer.compare(first.length(),
second.length());//Error:Variablefirstalreadydefined

如果在lambda表达式中引用this变量，则引用的是创建该lambda表达式的方法的this变量，如：

publicclassApplication(){
publicvoiddoWork(){
Runnablerunner=()->{
...;
System.out.println(this.toString());
...
};
}
}

所以这里的this.toString()调用的是Application对象的toString()，而不是Runnable
对象的。

DefaultMethod
接口中只能有抽象方法，如果在已有的接口中新增一个方法，则该接口所有的实现类都需要实现该方法。
Java8中引入了DefaultMethod的概念，在接口中新增一个default方法，不会破坏已有的接
口规则，接口的实现类可以选择重写或直接继承该default方法，比如：

interfacePerson{
longgetId();
defaultStringgetName(){return"JohnQ.Public";}
}

Java是允许多继承的，如果一个类的父类中定义的方法和接口中定义的default方法完全相同，或者
一个类的两个接口中定义了完全相同的方法，则如何处理这种冲突呢？处理规则如下：

如果是父类和接口的方法冲突：以父类中的方法为准，接口中的方法被忽略；
如果两个接口中的default方法冲突，则需要重写该方法解决冲突；

StaticMethod
Java8之前，接口中只能定义static变量，Java8开始，接口中可以添加static方法，比如
Comparator接口新增了一系列comparingXXX的static方法，比如：

publicstatic<T>Comparator<T>comparingInt(ToIntFunction<?superT>
keyExtractor){
Objects.requireNonNull(keyExtractor);
return(Comparator<T>&Serializable)
(c1,c2)->Integer.compare(keyExtractor.applyAsInt(c1),
keyExtractor.applyAsInt(c2));
}

使用这个static方法，以下两种方式也是等价的：

1、

Arrays.sort(cities,(first,second)->Integer.compare(first.length(),
second.length()));

2、

Arrays.sort(cities,Comparator.comparingInt(String::length));

所以，以后我们在设计自己的接口时，不需要再定义单独的工具类（如Collections/Collection)，
在接口中使用static方法就行了。

匿名内部类

在Java世界中，匿名内部类可以实现在应用程序中可能只执行一次的操作。例如，在Android应用程序中，一个按钮的点击事件处理。你不需要为了处理一个点击事件单独编写一个独立的类，可以用匿名内部类完成该操作：

Buttonbutton=(Button)findViewById(R.id.button1);
button.setOnClickListener(newOnClickListener(){

@Override
publicvoidonClick(Viewview){
Toast.makeText(MainActivity.this,"ButtonClicked",Toast.LENGTH_SHORT).show();
}

});

Lambda示例 1.RunnableLambda 来看几个示例，下面是一个Runnable的示例：

publicvoidrunnableTest(){
System.out.println("===RunnableTest===");
//一个匿名的Runnable
Runnabler1=newRunnable(){
@Override
publicvoidrun(){
System.out.println("Helloworldone!");
}
};
//LambdaRunnable
Runnabler2=()->System.out.println("Helloworldtwo!");
//执行两个run函数
r1.run();
r2.run();
}

publicvoidrunnableTest(){
System.out.println("===RunnableTest===");
//一个匿名的Runnable
Runnabler1=newRunnable(){
@Override
publicvoidrun(){
System.out.println("Helloworldone!");
}
};

//LambdaRunnable
Runnabler2=()->System.out.println("Helloworldtwo!");

//执行两个run函数
r1.run();
r2.run();
}

这两个实现方式都没有参数也没有返回值。Runnablelambda表达式使用代码块的方式把五行代码简化为一个语句。
2.ComparatorLambda 在Java中，Comparator接口用来排序集合。在下面的示例中一个ArrayList中包含了一些Person对象，并依据Person对象的surName来排序。下面是Person类中包含的fields:

publicclassPerson{
privateStringgivenName;
privateStringsurName;
privateintage;
privateGendergender;
privateStringeMail;
privateStringphone;
privateStringaddress;
}

publicclassPerson{
privateStringgivenName;
privateStringsurName;
privateintage;
privateGendergender;
privateStringeMail;
privateStringphone;
privateStringaddress;
}

下面是分别用匿名内部类和Lambda表达式实现Comparator接口的方式：

publicclassComparatorTest{
publicstaticvoidmain(String[]args){
List<Person>personList=Person.createShortList();
//使用内部类实现排序
Collections.sort(personList,newComparator<Person>(){
publicintcompare(Personp1,Personp2){
returnp1.getSurName().compareTo(p2.getSurName());
}
});
System.out.println("===SortedAscSurName===");
for(Personp:personList){
p.printName();
}
//使用Lambda表达式实现
//升序排列
System.out.println("===SortedAscSurName===");
Collections.sort(personList,(Personp1,Personp2)->p1.getSurName().compareTo(p2.getSurName()));
for(Personp:personList){
p.printName();
}
//降序排列
System.out.println("===SortedDescSurName===");
Collections.sort(personList,(p1,p2)->p2.getSurName().compareTo(p1.getSurName()));
for(Personp:personList){
p.printName();
}
}
}

publicclassComparatorTest{
publicstaticvoidmain(String[]args){
List<Person>personList=Person.createShortList();

//使用内部类实现排序
Collections.sort(personList,newComparator<Person>(){
publicintcompare(Personp1,Personp2){
returnp1.getSurName().compareTo(p2.getSurName());
}
});

System.out.println("===SortedAscSurName===");
for(Personp:personList){
p.printName();
}

//使用Lambda表达式实现

//升序排列
System.out.println("===SortedAscSurName===");
Collections.sort(personList,(Personp1,Personp2)->p1.getSurName().compareTo(p2.getSurName()));
for(Personp:personList){
p.printName();
}

//降序排列
System.out.println("===SortedDescSurName===");
Collections.sort(personList,(p1,p2)->p2.getSurName().compareTo(p1.getSurName()));
for(Personp:personList){
p.printName();
}
}
}

可以看到匿名内部类可以通过Lambda表达式实现。注意第一个Lambda表达式定义了参数的类型为Person；而第二个Lambda表达式省略了该类型定义。Lambda表达式支持类型推倒，如果通过上下文可以推倒出所需要的类型，则可以省略类型定义。这里由于我们把Lambda表达式用在一个使用泛型定义的Comparator地方，编译器可以推倒出这两个参数类型为Person。

Java编程中使用lambda表达式的奇技淫巧

热门推荐

随机推荐