基本概念

语法

// 1. 不需要参数,返回值为 2
() -> 2
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的和
(x, y) -> x + y
// 4. 接收2个int型整数,返回他们的乘积
(int x, int y) -> x * y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)

---

函数式接口

定义：一个接口有且只有一个抽象方法

例子：

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}

我们来给test()里面加点内容并实现，采用创建匿名内部类的方法，重写test()并打印

    public static void main(String[] args) {
        //匿名内部类
        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
            @Override
            public void test() {
                System.out.println("重写test方法");
            }
        };
        noParameterNoReturn.test();
    }

但现在有了lambda表达式，上面那段代码就可以简化了

    public static void main(String[] args) {
        NoParameterNoReturn noParameterNoReturn = ()-> System.out.println("重写test方法");
        noParameterNoReturn.test();
    }

---

其他的函数式接口

//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
public class Test {
    public static void main(String[] args) {
        OneParameterNoReturn oneParameterNoReturn = (a) -> {
            System.out.println("oneParameterNoReturn:" + a);
        };
        oneParameterNoReturn.test(10);
    }
}

//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}
public class Test {
    public static void main(String[] args) {
        MoreParameterNoReturn moreParameterNoReturn = (a,b) -> System.out.println(a+b);
        moreParameterNoReturn.test(1,2);
    }
}

//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
public class Test {
    public static void main(String[] args) {
        //NoParameterReturn noParameterReturn = ()->{return 10;};
        NoParameterReturn noParameterReturn = ()->10;
        System.out.println(noParameterReturn.test());
    }
}

//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
public class Test {
    public static void main(String[] args) {
        OneParameterReturn oneParameterReturn = a->a+10;
        System.out.println(oneParameterReturn.test(1));
    }
}

//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}
public class Test {
    public static void main(String[] args) {
        MoreParameterReturn moreParameterReturn = (a,b) -> a+b;
        System.out.println(moreParameterReturn.test(1, 2));
    }
}

一些精简策略

1. 参数类型可以省略，如果需要省略，每个参数的类型都要省略。

2. 参数的小括号里面只有一个参数，那么小括号可以省略

3. 如果方法体当中只有一句代码，那么大括号可以省略

4. 如果方法体中只有一条语句，且是 return 语句，那么大括号可以省略，且去掉 return 关键字。

---

变量捕获 

    public static void main(String[] args) {
        int a = 10;
        NoParameterNoReturn noParameterNoReturn = ()->{
            System.out.println("捕获变量："+a);
        };
        noParameterNoReturn.test();
    }

这里的变量a就是采用lambda表达式捕获的变量，这个变量在使用前不能被修改，要不然就加个final就不怕手贱修改了

---

lambda表达式的接口

 比如我们要打印下面的字符串

"bit";
"lambda";
"hello";

1.ArrayList类实现

        ArrayList<String> list = new ArrayList<>();
        list.add("bit");
        list.add("lambda");
        list.add("hello");

1.1 forEach()方法

这个方法实现了Consumer接口，我们需要做的就是重写这个accept方法让它打印字符串就行

        //不用lambda
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        //lambda
        list.forEach(s -> System.out.println(s));

1.2 sort()方法

这个方法实现Coparator接口，重写compare方法打印字符串

        //lambda
        list.forEach(s -> System.out.println(s));
        //不用lambda
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        //lambda
        list.sort((o1, o2) -> o1.compareTo(o2));

2.Map实现

        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "hello");
        map.put(2, "bit");
        map.put(4, "lambda");

forEach()方法

        //不用lambda
        map.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer integer, String s) {
                System.out.println("key: "+integer+" val: "+s);
            }
        });
        //lambda
        map.forEach((key,val)->System.out.println("key: "+key+"