什么是lambda表达式
lambda表达式是java8引入的新功能，它是一个可传递的代码块，可以在以后执行一次或多次。
接口与回调
在讲解lambda表达式之前，我们先讲一下接口。在java里实现回调，基本都是通过接口来完成的。代码如下：
public interface ActionListener {
void actionPerformed(ActionEvent event);
}
class TimePrinter implements ActionListener {
public void actionPerformed(ActionEvent event) {
System.out.println("At the tone, the time is " + new Date());
Toolkit.getDefaultToolkit().beep();
}
}
ActionListener listener = new TimePrinter();
Timer t = new Timer(10000, listener);
通过接口，我们可以实现将代码块封装到一个类里面，在需要调用的时候执行接口方法就可以了。
lambda表达式语法
回到lambda表达式。如果需要比较一个字符串是否比另一个字符串长，可以用lambda表达式：
(String first, String second)
-> first.length() - second.length()
可以看到，lambda表达式的形式为：参数，箭头（->）以及一个表达式。
当表达式很复杂时，可以使用{}块，在里面写复杂逻辑。例如：
(String first, String second) ->
{
if (first.length() < second.length()) return -1;
else if (first.length() > second.length()) return 1;
else return 0;
}
当lambda表达式没有参数时，也需要使用空括号，就像无参数方法一样：
() -> { for (int i = 100; i >= 0; i--) System.out.println(i); }
用lambda表达式实现回调
之前用接口实现的逻辑，现在就可以用lambda表达式来重新实现一遍了：
Timer t = new Timer(1000, event -> {
System.out.println("At the tone, the time is " + new Date());
Toolkit.getDefaultToolkit().beep();
});
lambda表达式，还可以保存到变量里，放在以后执行：
@FunctionalInterface
public interface BiFunction<T, U, R> {
/**
* Applies this function to the given arguments.
*
* @param t the first function argument
* @param u the second function argument
* @return the function result
*/
R apply(T t, U u);
}
import java.util.function.BiFunction;
public class Main {
public static void main(String[] args) {
BiFunction<String, String,String> bi = (x, y) -> {
return x + y;
};
System.out.println(bi.apply("youni", " youzan"));
}
}
/*output:
youni youzan
*/
总结一下，lambda表达式的优缺点。
优点：直观明了，可读性好。
缺点：不能复用逻辑。
方法引用
如何将现成的方法放到lambda表达式里？
Timer t = new Timer(1000, event -> System.out.println(event));
以上程序可以简写成：
Timer t = new Timer(1000, System.out::println);
可以用::操作分隔方法名与对象或类名。主要有3种情况：
- object::instanceMethod
- Class::staticMethod
- Class::instanceMethod
object::instanceMethod
参数直接透传到对应对象的实例方法，例如System.out::println(x) 等价于 x -> System.out.println(x)。
Class::staticMethod
参数直接透传到具体类的静态方法，例如(x, y) -> Math::pow(x, y) 等价于(x，y) -> Math.pow(x, y)。
Class::instanceMethod
这个稍微有点不符合我们的习惯用法，类的实例方法，应该是不能直接调用的。
这里就涉及到编译器的推导功能了。当使用分隔符时，编译器会自动推导应该用哪种方式。
例如(x, y) -> String::compareToIgnoreCase(x, y) 等价于 (x, y) -> x.compareToIgnoreCase(y)。
函数式接口
对于只有一个抽象方法的接口， 需要这种接口的对象时， 就可以提供一个 lambda 表达 式。 这种接口称为函数式接口 (functional interface )。
public Timer(int delay, ActionListener listener);
public interface ActionListener extends EventListener {
/**
* Invoked when an action occurs.
*/
public void actionPerformed(ActionEvent e);
}
Timer t = new Timer(1000, event ->
System.out.println("The time is " + new Date()));
t.start();
这里的ActionListener就是函数式接口。
变量作用域
在实际的业务开发中，在使用lambda表达式的时候，会遇到报错。例如一下代码。
public class FooService {
@Resource
private FooDao fooDao;
@Resource
private BarDao barDao;
public void foo(boolean addBar) {
List<Foo> foos = fooDao.listFoo();
Bar bar = null;
if (addBar) {
bar = barDao.getBar();
}
foos.stream().forEach(e -> {
if (bar == null) {
update(e);
}
});
}
private void update(Foo e) {
}
}
ide会提示：variable used in lambda expression should be final or effectively final。
什么意思？这里就涉及到lambda表达式的变量作用域了。
lambda表达式有3个部分：
- 一个代码块；
- 参数；
- 自由变量的值，这是指非参数而且不在代码中定义的变量。
在lambda表达式中，只能引用值不会改变的变量。
上面的报错，就是bar变量声明以后可能会有修改，导致了报错。
参考资料：
《Java核心技术 卷I》
BiFunction example
