基本概念

语法

// 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() {@Overridepublic 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方法让它打印字符串就行

        //不用lambdalist.forEach(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}});//lambdalist.forEach(s -> System.out.println(s));

1.2 sort()方法

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

        //lambdalist.forEach(s -> System.out.println(s));//不用lambdalist.sort(new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {return o1.compareTo(o2);}});//lambdalist.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()方法

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