Java lambda 表达式入门

java 自1.8后引入了lambda 表达式，那么lambda表达式是什么呢，我们为什么要使用它呢，还有就是我用它了之后会对喔的代码造成什么影响呢？等等的这一系列问题我都将在未来的几天为大家逐一解答。

ok了，废话不多说，下面开始正文内容：

what is lambda 表达式

首先的话咱先来看看java官方文档给出的定义是这样滴：

Lambda Expressions

One issue with anonymous classes is that if the implementation of your anonymous class is very simple, such as an interface that contains only one method, then the syntax of anonymous classes may seem unwieldy and unclear. In these cases, you’re usually trying to pass functionality as an argument to another method, such as what action should be taken when someone clicks a button. Lambda expressions enable you to do this, to treat functionality as method argument, or code as data.

The previous section, Anonymous Classes, shows you how to implement a base class without giving it a name. Although this is often more concise than a named class, for classes with only one method, even an anonymous class seems a bit excessive and cumbersome. Lambda expressions let you express instances of single-method classes more compactly.

This section covers the following topics:

······

它的大概意思就是说当匿名类需要实现一个非常简单方法，例如只包含一个方法的接口，那么匿名类的语法可能会显得稍微复杂、没有必要，那么如何去简化一些匿名内部类 Anonymous Classes 的实现？哎~~~，对了，lambda表达式就可以简化这些步骤。

那么现在我们就先感受一下lambda表达式给我们带来的一丢丢小小的便利~~~

1. 简化匿名内部类的书写
   如以下代码所示，如果我们不使用lambda表达式，我们要开启一个新线程是需要这么写的：

   new Thread(new Runnable(){
   @Override
   public void run(){
   	System.out.println("hello lambda");
   }
   }).start();
   

   但当咱使用lambda表达式后只需要一行代码就可以搞定：

   new Thread(() -> System.out.println("hello lambda")).start();  
   

   代码分析：
   第一段代码使用了为Thread传递了一个匿名的Runable对象，然后通过重写Runable中的run方法来实现相关逻辑，匿名内部类虽然简化了内不类的相关繁琐行为，但还是不够简单；
   然后咱来看第二段代码，该段代码采用的是lambda表达式书写，直接省掉了接口名和函数名，写起来那才真叫一个舒服！！！

此时细心的小伙伴就会发现一个问题！！！

那我要是想要输入多行代码该怎么办呢???

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qZQgfWsJ-1634781054728)(https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSwVsO8xHZFBQugR3BU7U2jaipPl2mp4NCqwQ&usqp=CAU)]

能发现这个问题的lz都想给他一个课代表当了！！！

现在咱们来看一下lambda表达式的 语法：

lambda 表达式的语法格式如下：

(parameters) -> expression
或 
(parameters) ->{ statements; }

以下是lambda表达式的重要特征:

• **可选类型声明：**不需要声明参数类型，编译器可以统一识别参数值。
• **可选的参数圆括号：**一个参数无需定义圆括号，但多个参数需要定义圆括号。
• **可选的大括号：**如果主体包含了一个语句，就不需要使用大括号。
• **可选的返回关键字：**如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。

来源---- 菜鸟教程（https://www.runoob.com/java/java8-lambda-expressions.html）

在上面的两种用法中咱们可以发现：第二种用法有一个大括号 ,如果我们需要在lambda表达式中使用多行代码的时候就可以在这里边写。

• 举个栗子：

  new Thread(() -> {
          System.out.println("hello");
          System.out.println("lambda");
   }).start();  
  

此时，不带参的函数方法的使用情况介绍完毕，下面咱们开始聊一下带参函数的使用方法：

• 首先，咱们需要自定义一个带参的接口：

  public interface LambdaTest {
      <T> T[] sort(T arr[] );
  }
  

• next

  public static void main(String[] args) {
  
       int[] arr = {7, 3, 4, 6, 1};
      //重写接口排序算法  此时lz采用的是冒泡排序
      LambdaTest lambdaTest = arr1 -> {
          for (int i = 0; i < arr1.length; i++) {
              for (int j = i; j < arr1.length; j++) {
                  if (arr1[i] > arr1[j]) {
                      int tmp = arr1[i];
                      arr1[i] = arr1[j];
                      arr1[j] = tmp;
                  }
              }
          }
          //将排好序的数组返回 
          return arr1;
      };
      //调用sort方法对arr数组排序，并采用sort接收
      //var 会根据返回的类型自动判断所需的数据类型
      val sort = lambdaTest.sort(arr);
      //打印排序后的数组
      Arrays.stream(sort).forEach(System.out::println);
  
  }
  

2. 到此处，我想大家应该都应该已经猜到要实现lambda简写是需要有对应的抽象接口（这里有一点需要注意一下：那就是该接口中只能有一个未实现抽象方法,如果一个接口中有多个方法的时候需要使用default 修饰方法，并为其添加一个默认方法体）

   • 举个栗子：

     @FunctionalInterface
     public interface LambdaTest {
          int[] sort(int arr[]);
     
         default int getMax(int i, int b) {
             return i > b ? i : b;
         }
     }
     
     

   有的时候我们在编写接口的时候可能会不那么注意细节（例如：出现多个抽象方法），从而导致自己的接口无法使用lambda表达式，为了减少这样的失误频繁出现，我们可以在接口上面添加一个@FunctionalInterface 注解。有这个注解的接口就一定会可以使用lambda表达式简写（@FunctionalInterface 修饰的接口只能有一个抽象方法，如果多了或者没有都会出现异常）,简单的说就是@FunctionalInterface 会帮我们检查一下接口的规范性