什么是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个部分：

1. 一个代码块；
2. 参数；
3. 自由变量的值，这是指非参数而且不在代码中定义的变量。

在lambda表达式中，只能引用值不会改变的变量。
上面的报错，就是bar变量声明以后可能会有修改，导致了报错。

参考资料：
《Java核心技术 卷I》
BiFunction example