详解Lambda表达式

---

前言

一、Lambda的入门

1、什么是Lambda表达式

Lambda表达式是JAVA8中提供的一种新的特性，是一个匿名函数方法。可以把Lambda表达式理解为一段可以传递的代码，可以写出更简洁、更灵活的代码。

2、Lambda表达式使用条件

Lambda表达式可以认为是对匿名内部类的一种简化，但不是所有的匿名内部类都可以简化为Lambda表达式。

重点来了

只有函数式接口的匿名内部类才可以使用Lambda表达式来进行简化。

• 函数式接口不同于普通接口，较为特殊化。接口当中只有一个抽象方法是需要我们去实现的，Lambda表达式正好是针对这个唯一的抽象方法使用。

3、Lambda表达式的入门使用

拿接口的典型例子，线程来分析

1. 线程创建的两种方式：继承Thread方式、实现Runnable方式。

   Runable是一个接口，里面只有一个抽象方法是需要我们强制实现的，该接口就是一个函数式接口。

   public interface Runnable{
       void run();
   }
   1
   2
   3

2. 匿名内部方式创建线程

   public class carDemo {
       public static void main(String[] args) {
           Thread t1=new Thread(new Runnable() {
               @Override//这里重写Runnable接口里面的run()方法
               public void run() {
                   System.out.println("匿名内部类方式-启动线程");
               }
           });
           t1.start();
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11

3. Lambda表达式创建线程

   public static void main(String[] args) {
           Thread t1=new Thread(() -> System.out.println("匿名内部类方式-启动线程"));//看，多么简便、多么流畅，就问你，是不是已经爱上她了？
           t1.start();
   }
   1
   2
   3
   4

二、Lambda语法格式

1、Lambda表达式的标准语法格式

Lambda表达式就是对函数式接口中抽象方法的实现，是对其匿名内部类的一个简写，只保留了方法的参数列表和方法体，其他的成分可以省略。因此，Lambda表达式的格式非常简洁，只有三部分组成：

• 参数列表

• 箭头

• 方法体

  总结：(参数列表)->{方法体}

2、Lambda:省略模式

在Lambda标准格式的基础上，使用省略写法的规则为：

• 小括号内参数的参数类型可以省略。
• 小括号有且只有一个参数，则小括号可以直接省略。
• 如果大括号有且只有一个语句，无论是否有返回值，大括号、return关键字、分号可以省略。

3、Lambda省略模式代码实现

• 小括号内参数的参数类型可以省略。

  ​ 实战案例：

  • 定义一个计算器接口

    • public interface Calculator {
          int cal(int a);
      }
      1
      2
      3

  • 主方法当中实现计算机接口

    • public static void main(String[] args) {
             method(5, n -> {return n++; });
             /**
              * int cal(int a)；抽象方法当中，小括号当中只有一个参数，这里省略5的小括号，用n指代前面的5,进行接下来的操作
              */
         }
         public static void method(int num,Calculator calculator{
             //method方法当中传入一个int类型数字，和一个计算器接口
             int result=calculator.cal(num);//接口类调用抽象方法
             System.out.println("reuslt="+result);
         }
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11

  • 运行结果

    • reuslt=5
      1

• 小括号有且只有一个参数，则小括号可以直接省略。

  ​ 实战案例：

  • 创建一个Person类

    public class Person {
        private int age;
        private String name;
        public Person(String name,int age) {
            this.name = name;
            this.age = age;
        }
        public Person() {
        }
        @Override
        public String toString() {
            return  "年龄：" + age +",姓名：" + name ;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26

  • 在main方法当中使用Lambda表达式

     public static void main(String[] args) {
            Person[] persons = new Person[4];
            persons[0] = new Person("袁隆平", 25);
            persons[1] = new Person("邓稼先", 30);
            persons[2] = new Person("清华大学", 46);
            persons[3] = new Person("北京大学", 89);
            Arrays.sort(persons, (one, two) ->
                    one.getAge() - two.getAge());//将Persons放进Arrays.sort()方法当中，两个对象之间对比，进行升序排序
            for(Person p:persons){//forEach（）循环遍历整个persons数组，并打印
                System.out.println(p.toString());
            }
        }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

  • 运行结果

    年龄：25,姓名：袁隆平
    年龄：30,姓名：邓稼先
    年龄：46,姓名：清华大学
    年龄：89,姓名：北京大学
    1
    2
    3
    4

• 如果大括号有且只有一个语句，无论是否有返回值，大括号、return关键字、分号可以省略。

  ​ 实战案例：

  这里我就拿上面的Person类举例，直接在main主方法当中运行

  • 标准格式

    public static void main (String[]args){
            Person[] persons = new Person[4];
            persons[0] = new Person("袁隆平", 25);
            persons[1] = new Person("邓稼先", 30);
            persons[2] = new Person("清华大学", 46);
            persons[3] = new Person("北京大学", 89);
            Arrays.sort(persons, new Comparator<Person>() {
                public int compare(Person o1, Person o2) {
                    //这里有大括号和返回值               
                    return o1.getAge() - o2.getAge();
                }
            });
        }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

  • 简便格式

   Arrays.sort(persons, (one, two) -> one.getAge() - two.getAge());
            //这里已经去掉了大括号和返回值
            for (Person p : persons) {
                //forEach（）循环遍历整个persons数组，并打印
                System.out.println(p.toString());
            }
1
2
3
4
5
6

```java

 
```
1
2
3
4

• 运行结果

  同上

  年龄：25,姓名：袁隆平
  年龄：30,姓名：邓稼先
  年龄：46,姓名：清华大学
  年龄：89,姓名：北京大学
  1
  2
  3
  4