初探Java8lambda表达式

要说现在什么火， 估计函数式编程算一个吧，看看人家javascript写起来多爽，java呢？一切皆对象。好像离着函数式编程挺远的，不过在java8中我们终于迎来了类似函数式编程-Java风格的lambda表达式，在用lambda重构你的代码后，啥感觉？ 倍爽！

这篇博客我们就来小探一下java8的lambda表达式，领略一下lambda表达式的风骚！

lambda表达式语法

lambda的语句可以用以下伪代码表示，很简单，不过还有很多更简单的表达方式，

(Type ...argument) -> {code}

还有一下变种方式，

(Type ...argument) -> x * y // 执行x * y , 注意有返回值的情况下，这里会自动推导返回

初探lambda表达式

只看语法没什么卵用，最好的学习方法还是在实践中去掌握它。先来几个简单的尝尝鲜吧：用lambda表达式去遍历一个List。在没有lambda之前，我们是怎么遍历一个List的呢？相信大家很熟悉，

List<String> list = Arrays.asList("aaa", "bbb", "ccc");
for(String item : list) {
    System.out.println(item);
}

不多说， 再来看看lambda怎么做，

List<String> list = Arrays.asList("aaa", "bbb", "ccc");
list.forEach((item) -> System.out.println(item));

一行代码搞定！关键代码就是(item) -> System.out.println(item)，这样的语法在上面我们已经介绍了，因为只有一句表达式，所以{}可以省略。
等等，上面的方式还不是最简单的，

List<String> list = Arrays.asList("aaa", "bbb", "ccc");
list.forEach(System.out::println);

哎哟，这什么玩意！ 嘿嘿，System.out::println等同于(x) -> System.out.println(x)。这种语法我们在下面会详细讲解。

和上面遍历相似，我们再来看看线程现在该怎么写，

new Thread(() -> {
   // do something
   System.out.println("hello thread");
}).start();

恩，简单不？ 而且有了上面的基础，也很好理解了。

排序！排序！

在lambda中排序也简单了许多，看下面代码，

String[] array = {"bbb", "ddd", "aaa"};
Arrays.sort(array, (String a, String b) -> a.compareTo(b));

stream

在java8中,Collection多了一个stream方法，stream方法天生就是配合lambda来的，stream提供了好多好用的方法，例如filter用来过滤，下面的代码，我们只打印以a开头的字符串。

List<String> list = Arrays.asList("abc", "abb", "ddd");
list.stream().filter((String item) -> item.startsWith("a"))
        .forEach(System.out::println);

limit，类似sql中的limit，用来限制遍历个数，例如下面代码，我们将遍历List中的前5条数据，

List<String> list = Arrays.asList("abc", "abb", "ddd", "111", "ddd", "yyy", "999");
list.stream().limit(5).forEach(System.out::println);

关于Stream更多好玩的方法，可以去api中查看说明，这里就不一一讲解了。

自定义函数式接口

在上面的代码中，我们都是去使用了系统提供了函数式接口，那我们自己能不能自定义呢？答案是可以的，要自定义函数式接口必须符合以下两个条件。

1. 该接口中有且仅有一个方法。
2. 在接口上使用注解@FunctionalInterface (非必须，但良好的编程规范是加上)

遵循上面的规范，我们来自定义一个函数式接口吧，

@FunctionalInterface
interface Func {
    String builder(String firstName, String lastName);
}

哎（二声），一个函数接口搞定了，如何用呢？其实你已经会用了。

Func func = (String first, String last) -> {
 return first + "." + last;
};
System.out.println(func.builder("f", "l"));

恩，太熟悉了，不过估计有朋友想到了更简洁的代码，

Func func = (String first, String last) -> first + "." + last;
System.out.println(func.builder("f", "l"));

俩冒号是个啥

上面我们再用System.out::println的时候说了，System.out::println等同于(x) -> System.out.println(x)。现在就让我们来了解一下这个::。
::其实是一种依赖lambda自动推导的语法糖（纳尼？ 其实lambda表达式本身在java中就是一种语法糖），概念性的东西我也不会说，下面就让我们用3个例子来学习
一下这个::吧。

class Util {
    public static String getSomething(String a, String b) {
        return a + ";" + b;
    }
}

@FunctionalInterface
interface Func {
    public String get(String a, String b);
}

Func f = Util::getSomething;
System.out.println(f.get("aaa", "bbb"));

主要的代码就是Func f = Util::getSomething了，其实他就等同于Func f = (String a, String b) -> Util.getSomething(a, b)。其实就是用Util.getSomething()去实现了Func的get方法，不过这里看起来是不是有种Util实现了Func接口的感觉，嘿嘿。
上面的getSomething是一个静态方法，如果是实例方法呢？

class Util {
    public String doGet(String a, String b) {
        return a + ";" + b;
    }
}
Util util = new Util();
Func f2 = util::doGet;
System.out.println(f2.get("ccc", "ddd"));

那::和构造方法呢？

class Student {
    private String name;

    public Student(String name) {
        this.name = name;
        System.out.println(this.name);
    }
}

@FunctionalInterface
interface StudentInterface {
    Student build(String name);
}

StudentInterface si = Student::new;
Student stu = si.build("loader");

像不像静态工厂模式？恩？