Lambda入门，看这一篇幅就够了

jdk1.8中的lambda表达式学习笔记

一、引入一个例子

我们写一个多线程的例子,如下：采用实现Runable接口的方式

package cn.lyn4ever.lambda;

public class TestMain1 {
    public static void main(String[] args) {
        //线程1
        MyThread myThread1 = new MyThread();
        Thread t1 = new Thread(myThread1);
        t1.start();

        //线程2
        MyThread myThread2 = new MyThread();
        Thread t2 = new Thread(myThread2);
        t2.start();
    }

}

/**
 * 我们先写一个类来实现Runable接口,为了方便直接写进了这个类中
 */
class MyThread implements Runnable {

    @Override
    public void run() {
        System.out.println("这是一个多线程:" + Thread.currentThread().getId());
    }
}

当然，没有任命毛病。觉得自己写个类外部类太麻烦，那就写一个匿名内部类

package cn.lyn4ever.lambda;

public class TestMain2 {

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("这是一个线程:"+Thread.currentThread().getId());
            }
        }).start();
    }

}

这样还是不够简单，那就用lambda表达式好了.

		new Thread(()->{
            System.out.println("这是一个线程:"+Thread.currentThread().getId());
        }).start();

是的，就这么一句。看一个结果

二、函数式接口

所谓函数式接口，就是这个接口只有一个抽象方法，（可以包含静态方法和default方法，这是jdk1.8以后的特性），

自定义一个函数式接口的方法很简单，就是加了注解，编译器会帮我们检查代码合理性

@FunctionalInterface
public interface MyFunction {

    /**
     * 定义一个获取字母大写的方法
     * @return
     */
    String getUpperCase(String letter);

}

然后简单地应用下我们这个接口

 public static void main(String[] args) {
        //匿名内部类
        MyFunction myFunction = new MyFunction() {
            @Override
            public String getUpperCase(String letter) {
                //实现这个方法
                return letter.trim().toUpperCase();
            }
        };
        //然后调用方法
        System.out.println(myFunction.getUpperCase("this is MyFunctoinTest"));

        //lambda表达式
        MyFunction myFunction1 = (String letter)->{
            return letter.trim().toUpperCase();
        };

        //然后调用方法
        System.out.println(myFunction1.getUpperCase("this is MyFunctoinTest"));
    }

可以看到，我们定义的这个MyFunction接口并没有什么用，因为具体的实现是在匿名内部类中写的。

java.lang.Runable
java.lang.Comparable
java.lang.Comparator
java.lang.FileFilter
...

在java.util.function包中还定义了大量的功能性函数式接口，我们可以直接使用，而不用自己再去创建接口了。比如以下

1.java.util.Predicate 接收一个对象T,返回一个boolean类型结果

 //定义一个功能，如果输入0,这返回true,其他的返回false
        Predicate<Integer> predicate = (Integer param) -> {
            if (null != param && param == 0)
                return true;
            return false;
        };

        //直接调用predicate中的test方法
        System.out.println(predicate.test(12));

可以看一个Predicate的源代码

代码的结果肯定是false，不用看了。这个接口就可以满足我们的需求，只要我们想要 接收一个对象T,返回一个boolean类型结果这样的功能，完全不用单独定义方法，只要用这个类就可以了。

还有很多，就不举例子了，将它们的功能列举出来

java.util.function.Comsumer<T> 传入对象T，只是运算，不返回结果 （大家都知道，类作为形参时是地址引入）
<R> java.util.function.Funtion<T> 传入对象T，返回对象R
<T> java.util.function.Supplier 不接收参数，提供T对象
<T> java.util.function.UnaryOperator<T> 接收参数对象T,返回结果对象T
<T> java.util.function.BinaryOperator<T,T> 接收两个T对象，返回一个T对象(下边有个例子)

public static void main(String[] args) {

        BinaryOperator<Integer> binaryOperator = (Integer i, Integer j) -> {
            //返回两个数中较大的一个
            return i > j ? i : j;
        };

        System.out.println(binaryOperator.apply(12,13));//13
    }

三、Lambda表达式的基本语法

1.基本语法

• 0.基本语法:
  
  T r = new T { () -> {这里边是方法的具体实现} };
• 1.lambda表达式要和接口绑定，
• 2.如果表达式中方法的实现只有一条语句，可以不写{} 和 reutrn 关键字，否则必须要写(如果有返回值就要写reutrn,没有不用写)
• 3.如果接口中的方法有参数，在() 中参数的类型，可写可不写

看一个例子

package cn.lyn4ever.lambda.exmple;

public class ExampleDemo {
    public static void main(String[] args) {

        NoResultNoParam noResultNoParam = () -> System.out.println("NoResultNoParam");
        noResultNoParam.test();

        NoResultHasParam noResultHasParam = (param) -> System.out.println(param);
        noResultHasParam.test("hello");

        HasResultHasParam hasResultHasParam = (x, y) -> {
            int z = x + y;
            return z;
        };
        //下边这个也可以,只有一个返回值时，不用写{}
        HasResultHasParam hasResultHasParam1 = (x, y) -> x + y;
        System.out.println(hasResultHasParam.test(1,2));
        System.out.println(hasResultHasParam1.test(10,20));

    }

}

interface NoResultNoParam {
    void test();
}

interface NoResultHasParam {
    void test(String param);
}

interface HasResultHasParam {
    int test(int x, int y);
}

本文代码已上传至github,觉得好的话，给个star