lambda表达式

Lambda表达式的特性：

　　可以把Lambda表达式理解为简洁地表示可传递的匿名函数的一种方式：它没有名称，但它有参数列表、函数主体、返回类型，可能还有一个可以抛出的异常列表。

　　 匿名——我们说匿名，是因为它不像普通的方法那样有一个明确的名称：写得少而想得多！

　　 函数——我们说它是函数，是因为Lambda函数不像方法那样属于某个特定的类。但和方法一样，Lambda有参数列表、函数主体、返回类型，还可能有可以抛出的异常列表。

　    传递——Lambda表达式可以作为参数传递给方法或存储在变量中。

 　　简洁——无需像匿名类那样写很多模板代码。

Lambda表达式的组成：

　　Lambda表达式主要由三个部分组成：

　1，参数列表：可以是无参，也可以是多个参数，

　2，箭头：-> 作用是把参数和Lambda 主体分开。

　3，Lambda主体：这里写逻辑代码，可以有返回值，也可以没有返回值。

Lambda表达式虽然这三种组成部分是固定的，但是它的写法是多种多样的，下面我们就用java中常用的声明线程的的例子来逐一展示。

1，不用线程的声明方式：

Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("传统的声明线程的方式");
            }
        });

2，使用Lambda表达式方式：

Thread thread1 = new Thread(() -> System.out.println("Lambda方式声明"));

可以明显的感觉出用Lambda表达式要代码要简介明了很多，这里因为是无参，()就代表参数列表，箭头->,System.out.println("Lambda方式声明")代表主体，这里主体是简写的方式，

如果要写全的话应该这样写：

Thread thread2 = new Thread(() -> {
            System.out.println("Lambda方式声明");
        });

这里要特别注意如果用了{}就代表主体里面是代码块，代码块必须要以分号结束，否则无法通过编译。

3，我们再来看有参数和有返回值的例子：

我们先创建一个学生类，然后用java的Comparator接口来实现年龄排序

还是先来看看通过传统的方式怎么实现

        Student zhangsan = new Student("zhangsan", 15);

        Student lisi = new Student("lisi", 12);

        Comparator<Student> comparator = new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                if(o1.getAge()<o2.getAge()) return -1;
                if(o1.getAge()>o2.getAge()) return 1;
                return 0;
            }
        };
        System.out.println(comparator.compare(zhangsan,lisi));

然后再来看看用Lambda表达式怎么实现：

Comparator<Student> studentComparator = (Student o1, Student o2) -> {
            if (o1.getAge() < o2.getAge()) return -1;
            if (o1.getAge() > o2.getAge()) return 1;
            return 0;
        };
        System.out.println(studentComparator.compare(zhangsan,lisi));

这里注意看参数的写法，也可以将(Student o1, Student o2)简写成(o1,o2),如果是一个参数，甚至可以省略();方法体里面如果返回值的计算比较简单，也可以简写，

我们假设不考虑相等的情况，可以这样实现：

Comparator<Student> studentComparator = (o1, o2) -> o1.getAge()>o2.getAge()?1:-1;
System.out.println(studentComparator.compare(zhangsan,lisi));

什么情况下使用Lambda:

我们使用Runnable和Comparator举了几个Lambda的使用场景，查看这两个接口的源码，你会发现他们都拥有一个共同的注解@FunctionalInterface，

被@FunctionalInterface声明的接口被称为函数式接口，它的特点是只有一个抽象方法，即使包含其他方法也是default修饰的默认方法。你会发现我们在使用

Lambda表达式的时候，根本没有显示的调用具体的方法，这就很显然的印证了为什么只能有一个抽象方法了，你想如果有多个方法，我们这样写，编译器怎么

知道调用哪个方法呢。当然并不是必须要用@FunctionalInterface注解的接口才能使用Lambda，只要满足只有一个抽象方法的接口就可以使用。

常用的函数式接口：

 java 8常用的函数式接口java.util.function包中，常用的包括Consumer<T>,Function<T>,Supplier<T>,Predicate<T>

以 Predicate<T>为例，其他的看下源码自然就懂了。

我们来详细看看Predicate接口的组成

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

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

可以看见函数式接口并不是只包含一个抽象方法，java 8为了兼容以前的方法，采用了默认方法和静态方法，这样既保留了以前的方法，又可以实现函数式编程。

Predicate接口的使用，从唯一的抽象方法test可以看出，该函数式接口的使用是传入一个参数，返回固定的boolean值。该接口的主要使用在Stream处理集合是

的filter。先来看看Predicate的常规使用：

举个简单的例子，java 8以前，如果你想判断一个整数是奇数还是偶然，你可能会这样写。

        int a = 0;
        boolean flag;
        if(a%2==0){
            flag = true;
        }else {
            flag = false;
        }

用Lambda表达实现：

　　　　 int a = 0;
        Predicate<Integer> predicate = (integer)->integer%2==0;
        System.out.println(predicate.test(a));

看上去这样写并没有什么好处，我们再来看一个例子，我们有一个包含多个整数的数组，我们要返回所有的整数并打印。

int[] ints = {2, 23, 3, 8, 10, 7, 20, 0, 9, 10, 11, 13, 28};
Arrays.stream(ints)
        .filter((i) -> i % 2 == 0)
        .forEach(System.out::println);

 我们可以看到将lambda表达式和stream结合起来，可以很轻松的实现，lambda表达式和流式编程式密不可分的。后续文章会专门对steam进行讲解。

方法的引用：

你为什么应该关心方法引用？

方法引用可以被看作仅仅调用特定方法的Lambda的一种快捷写法。它的基本思想是，如果一个Lambda代表的只是“直接调用这个方法”，那最好还是用名称

来调用它，而不是去描述如何调用它。事实上，方法引用就是让你根据已有的方法实现来创建Lambda表达式。但是，显式地指明方法的名称，你的代码的可读性会更好。

它是如何工作的呢？

当你需要使用方法引用时，目标引用放在分隔符::前，方法的名称放在后面，注意方法的的后面式没有括号的。在上面的例子，我已经使用了方法的引用了，我们来分析下

是如何使用的。假如不使用方法的引用，应该这样写：

Arrays.stream(ints)
        .filter((i) -> i % 2 == 0)
        .forEach(i-> System.out.println(i));

forEach中我们用了一个IntConsumer的函数式接口，传入一个int值，但是没得返回值，又学到一个函数式接口，哈哈。接下来看怎么把它转成方法的引用，我们先找到最关键的方法，

即println，此时按照定义应该这样写::println,现在就差目标引用了及System.out加起来就是System.out::println。