java8-01-lambda

[TOC]

0 lambda的传说

其实我也没法说清楚他到底是什么鬼……

就好比你没见过某种颜色，我再怎么描述都没法描述清楚，还是亲自看看他长啥样吧

还记得中学的时候，数学里经常出现的那个符号吗？

先放一个从百度图库偷来的图片(CSDN打上的水印，不关我事哈……)

lambda

就是这货，此处的lambda 就是它……

传说中这玩意儿是比程序员还疯狂的数学家的口头禅……

上面的废话都看完了？？？？

虽然见到了他，但是还是不清楚他到底是什么……

好了，不扯皮了，开讲啦

百科里是这么描述的：

Lambda 表达式”是一个匿名函数，可以包含表达式和语句，并且可用于创建委托或表达式目录树类型。

看百科的描述好像有那么点感觉了。可是干嘛非要搞个这么高冷的解释呢？

个人是这么理解的：

lambda 类似于一个可调用的代码块或者游离函数。当然也可以有入参。

1 瞄一眼他长啥样?

示例

比如下面这样：

Comparator<Integer> c = (i, j) -> Integer.compare(i, j);

等价的原始Java代码长这样：

Comparator<Integer> c = new Comparator<Integer>() {
  @Override
  public int compare(Integer o1, Integer o2) {
    return Integer.compare(o1, o2);
  }
};

用上lambda是什么体验？

代码量好像少了
逼格好像提高了
代码好像更优雅了

2 lambda各种外观

至少在Java里lambda的爸爸妈妈姐姐弟弟爷爷奶奶七大姑八大姨……可能都是长这个样子的。

同时，据老夫多年的断案经验来推断，lambda的本尊应该也是这个样子的：

(Type1 param1,Type2 param2, ...) -> {
  // 一些乱七八糟、乌漆嘛黑的处理操作();
  return ret;
}

外观一：没有入参的时候

()->{return ret;}

外观二：有参数的时候

(Type p)->{return ret;}

// 参数类型可以省略(隐式推掉)
(p)->{return ret;}

// 一个参数的时候，参数列表外的括号也可以没有
p->{return ret;}

外观三：函数体只有一行的时候

// 方法体只有一行的时候,或括号连同结尾的分号都可以省略
e->ret

外观四：没有返回值的时候

e->{}

方法引用和构造器引用
- instance::instanceMethod
- className::staticMethod
- className::instanceMethod

Arrays.asList(null, "", "   ", "HelloWorld", "ByeBug")//
  .stream().filter(StringUtils::isNotBlank)//
  .forEach(System.out::println);

……

3 lambda使用场景

再看一个例子：

// 原始方法启动一个线程
new Thread(new Runnable() {
  @Override
  public void run() {
  }
}).start();

// lambda版
new Thread(()->{}).start();

不难看出，整个匿名内部类中最关键的代码其实就是：

public void run() {
}

所以，lambda中关键部分也就是这部分代码了。

其实，用注解java.lang.FunctionalInterface修饰的接口都可以用于lambda表达式中。

这种接口，都是只有一个方法的接口。

另外，只要你的接口只有一个方法，即使是没有@FunctionalInterface注解修饰,也是可以用lambda的(很多时候编译器还是很聪明的,他会自动推断的)。

总之，lambda只钟爱函数式接口(@FunctionalInterface)。

4 再来个示例

public class HouseInfo {

    private Integer houseId; // 小区ID
    private String houseName;// 小区名
    private Integer browseCount; // 浏览数
    private Integer distance;// 距离 KM
    // constructor
    // getters
    // setters
}

有如下数据

List<HouseInfo> houseInfos = Lists.newArrayList(//
    new HouseInfo(1, "恒大星级公寓", 100, 1), //
    new HouseInfo(2, "汇智湖畔", 999, 2), //
    new HouseInfo(3, "张江汤臣豪园", 100, 1), //
    new HouseInfo(4, "保利星苑", 23, 10), //
    new HouseInfo(5, "北顾小区", 66, 23), //
    new HouseInfo(6, "北杰公寓", null, 55), //
    new HouseInfo(7, "保利星苑", 77, 66), //
    new HouseInfo(8, "保利星苑", 111, 12)//
);

按距离排序

Collections.sort(houseInfos, (h1, h2) -> {
    if (h1 == null || h2 == null)
      return 0;
    if (h1.getDistance() == null || h2.getDistance() == null)
      return 0;
    return h1.getDistance().compareTo(h2.getDistance());
});

输出小区名

houseInfos.stream().map(h -> h.getHouseName()).forEach(System.out::println);

动态条件过滤

// 该函数式接口用来当做测试条件
public static interface Condition<T> {
  boolean conditionTest(T e);
}

// 定义一个方法来输出满足condition测试结果的小区
public void printWithFilter(List<HouseInfo> houseList, Condition<HouseInfo> condition) {
  houseList.stream().filter(e -> condition.conditionTest(e)).forEach(System.out::println);
}

@Test
public void test4() {
  List<HouseInfo> houseInfos = Lists.newArrayList(//
    new HouseInfo(1, "恒大星级公寓", 100, 1), //
    new HouseInfo(2, "汇智湖畔", 999, 2), //
    new HouseInfo(3, "张江汤臣豪园", 100, 1), //
    new HouseInfo(4, "保利星苑", 23, 10), //
    new HouseInfo(5, "北顾小区", 66, 23), //
    new HouseInfo(6, "北杰公寓", null, 55), //
    new HouseInfo(7, "保利星苑", 77, 66), //
    new HouseInfo(8, "保利星苑", 111, 12)//
  );
  // 打印小区名包含北字的小区
  printWithFilter(houseInfos, e -> e != null && e.getHouseName().contains("北"));
  // 打印距离大于10KM的小区
  printWithFilter(houseInfos, e -> e != null && e.getDistance() != null && e.getDistance() > 10);
}

字符串转大写

Arrays.asList("HelloWord", "ByeBug")
  .stream().map(String::toUpperCase).forEach(System.out::println);

其实在Scala里lambda更加直观

List("HelloWord", "ByeBug").map(_.toUpperCase()).foreach(println _);

5 lambda的好基友

通过上面的示例，再结合实际。不难发现最常用的lambda的形式如下：

单个输入，无输出
单个输入，单个输出
无输入，输出单个类型
两个不同类型的输入，第三种类型的输出
两个不同类型的输入，其中一种类型的输出
……

其实在每次使用的时候，没必要自己去新建这些函数式接口以支持lambda，JDK就已经给lambda内置了很多好基友:

Consumer: 单个输入，无输出

public interface Consumer<T> {
  void accept(T t);
}

BiConsumer: 两个不同类型的输入，无输出

public interface BiConsumer<T, U> {
  void accept(T t, U u);
}

Supplier: 无输入，输出单个类型

public interface Supplier<T> {
  T get();
}

Function: 两个不同类型的输入

public interface Function<T, R> {
  R apply(T t); // 输入T类型,转换成R类型
}

ToIntFunction / ToLongFunction / ToDoubleFunction

public interface ToIntFunction<T> {
    // T类型的输入,输出int 
    // 类似于Stream的mapToInt()
    int applyAsInt(T value); 
}

IntFunction / LongFunction / DoubleFunction

public interface IntFunction<R> {
    R apply(int value);
}

BiFunction: 两个不同类型的输入，第三种类型的输出

public interface BiFunction<T, U, R> {
  R apply(T t, U u);
}

条件测试

public interface Predicate<T> {
  boolean test(T t);
}

可以不用自定义函数式接口来支持lambda，上面的例子可以改成：

public void printWithFilter(List<HouseInfo> houseList, Predicate<HouseInfo> condition) {
  houseList.stream().filter(e -> condition.test(e)).forEach(System.out::println);
}

关于lambda的传说和他到底是什么鬼，看到这里应该够了。

毕竟我们的主要目的是使用它，知道他怎么用才是重点。

没必要纠结他严格的学术定义(这种事不应该是那种只会纸上谈兵的老不死干的吗？)。

在Java8里和lambda相关的主要API就是Stream了。在了解Stream的时候来顺便熟悉lambda吧。