Java之Lambda表达式

1、什么是Lambda表达式

Lambda表达式，也可称为闭包也称匿名函数。
闭包函数：声明在一个函数中的函数，叫做闭包函数。
可以理解成一个方法中的方法，没有方法名，但是有参数与方法体。

Lambda表达式是java1.8的一个新特性，早于1.8版本无法使用。
它是推动Java8发布的最重要的新特性。

2、为什么使用Lambda表达式

我们可以把Lambda表达式理解为一段可以传递的代码
（将代码像数据一样进行传递）。Lambda允许把函数作
为一个方法的参数，使用Lambda表达式可以写出更简洁、
更灵活的代码，而其作为一种更紧凑的代码风格，
使Java的语言表达能力得到了提升。

简单来讲就是能够使你的代码更加的简洁（装逼），但是身为程序员我们可能平时使用Lambda表达式的机会不多，但是一定要做到能看懂。

3、Lambda表达式语法

Lambda表达式在Java语言中引入了一个操作符**“->”**，该操作符被称为Lambda操作符或箭头操作符。它将Lambda分为两个部分：

左侧：指定了Lambda表达式需要的所有参数
右侧：制定了Lambda体，即Lambda表达式要执行的功能。
左侧 -> 方法体

例如：

(x)-> System.out.println(x);

这里我能的x就是传入的参数，箭头指向的就是我们的方法体。

1、语法格式

(1) 语法格式一：无参，无返回值，Lambda体只需一条语句

public void test01(){
    Runnable runnable=()-> System.out.println("Runnable 运行");
    runnable.run();//结果：Runnable 运行
  }

(2) 语法格式二：Lambda需要一个参数，无返回值。如下：

public void test02(){
Consumer<String> consumer=(x)-> System.out.println(x);

    consumer.accept("Hello Consumer");//结果：Hello Consumer

}

(3) 语法格式三：Lambda只需要一个参数时，参数的小括号可以省略，如下：

public void test02(){
Consumer<String> consumer=x-> System.out.println(x);

consumer.accept("Hello Consumer");//结果：Hello Consumer

}

(4) 语法格式四：Lambda需要两个参数，并且Lambda体中有多条语句。

public void test04(){
    Comparator<Integer> com=(x, y)->{
      System.out.println("函数式接口");
      return Integer.compare(x,y);
}

（5）语法格式五：有两个以上参数，有返回值，若Lambda体中只有一条语句，return和大括号都可以省略不写

public void test05(){
    Comparator<Integer> com=(Integer x, Integer y)-> Integer.compare(x,y);
System.out.println(com.compare(4,2));
}

6 Lambda表达式的参数列表的数据类型可以省略不写，因为JVM可以通过上下文推断出数据类型，即“类型推断”

public void test06(){

Comparator<Integer> com=(x, y)-> Integer.compare(x,y);

System.out.println(com.compare(4,2));//结果：1

  }

说了这么多可以一句话概括Lambda表达式的书写方法

    public interface A{

        String a(String b,String c);

    }
    public class B implements A{
        @Override
        public String a(String b, String c) {
            return b+c;
        }
    }

其中我们不需要知道Class B 的名字，同样也不需要a方法的名字
所以都可以省略，返回值的类型我们可以通过上下文可以推断出来，String的返回值类型也可以省略，参数的类型也可以通过判断得到。

因此就得到了以下的情况：

public interface A{
String a(String b,String c);
}
public class B implements A{
@Override
public String a (String b, String c) {
return b+c;
}
}

所以就得到Lambda表达式为：

（b,c）->b+c;

最后由我们的接口类型一接。

A a = （b,c）->b+c;

就得到了我们最终的表达式。

4、函数式接口

4.1 什么是函数式接口

只包含一个抽象方法的接口，就称为函数式接口。我们可以通过Lambda表达式来创建该接口的实现对象。
我们可以在任意函数式接口上使用@FunctionalInterface注解，这样做可以用于检测它是否是一个函数式接口，同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。

我们在使用lambda表达式的时候，通常需要定义一个接口，如果我们每次都去定义一个接口，显然是有点儿麻烦的，
所以java8中提供了四个内置的函数式接口，通过直接使用这四个接口，或者使用它们的扩展接口，就可以让我们很方便的使用lambda表达式。

Consumer:
表示接受单个输入参数且不返回结果的操作。与大多数其他功能接口不同，消费者预计将通过副作用操作。
返回按顺序执行此操作的组成消费者，然后是后续操作。如果执行任一操作抛出例外情况，则将其中继到组成操作的呼叫者。如果执行此操作抛出一个例外，则不会执行后操作

public static void makeMoney(Integer money, Consumer<Integer> consumer){
        consumer.accept(money);
    }

    public static void test01(){
        makeMoney(100,t-> System.out.println("今天赚了"+t));//结果：今天赚了100
    }

Supplier: 代表结果的供应商。
每次调用供应商时，均不要求退回新的或不同的结果。

 public static void test02(){
        List list = addNumInList(10, () -> (int) (Math.random() * 100));
        list.forEach(t-> System.out.println(t));
    }
    public static List addNumInList(int size, Supplier<Integer> supplier){
        List<Integer> list=new ArrayList();
        for (int i = 0; i < size; i++) {
            list.add(supplier.get());
        }
        return list;
    }

Function: 表示接受一个参数并产生结果的函数。
这是一个功能界面，其功能方法是应用（对象）。

public static String handleStr(String s, Function<String, String> f){
        return f.apply(s);
    }
    public static void test03(){
        System.out.println(handleStr("abc",(String s)->s.toUpperCase()));
    }

Predicate: 表示一个论点的谓词（布尔值函数）。
这是一个功能界面，其功能方法是测试（对象）。

 public static void test04(){
        List<String> strings = Arrays.asList("啊啊啊", "2333", "666", "?????????");
        List<String> stringList = filterStr(strings, (s) -> s.length() > 3);
        for (String s : stringList) {
            System.out.println(s);
        }
    }

Lambda表达式的基本使用的方法就是这样，在就接口中还包含了很多我们能使用的方法，我就不一一列举了，有兴趣的可以翻一翻api。

感谢阅读