Lambda表达式

Lambda函数式编程思想

语法格式

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

Lambda表达式是一个匿名函数，基于数学中的λ演算得名

面向对象过程强调的是通过对象的形式来做事情，调用对象的方法来完成事情

而函数式编程思想强调的是做什么，而不是以什么形式做，只看结果，不看过程

Lambda表达式使用前提

1. 使用Lambda表达式必须具有接口，且要求接口中有且仅有一个抽象方法，比如Runnable接口和Comparator接口

2. 使用Lambda表达式必须具有上下文推断，也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例

Lambda表达式省略格式

Lambda表达式语法：(参数列表) -> {方法体}

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

如果小括号内有且仅有一个推断类型参数，则小括号可以省略

如果大括号内有且仅有一个语句即一行语句，则无论是否有返回值，都可以省略大括号、return关键字和语句分号，要注意的是如果要省略那么要一起省略

举例

参数列表只有一个参数时：

show((int a)->{
   return a++;
});

省略格式(省略了{}、return、语句分号、参数的数据类型int、小括号() )

show( a -> a++ );

参数列表多个参数时：

show((int a, int b)->{
      return a+b;
});

省略格式(省略了{}、return、语句分号、参数的数据类型int )

show((a,b)->a+b);

Lambda表达式的应用

当实现多线程时，可以实现Runnable接口创建Thread线程

传统写法

//使用匿名内部类实现多线程
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"创建该线程");
    }
}).start();

这里面当中有很多冗余的代码

使用Lambda表达式

new Thread(()-> System.out.println(Thread.currentThread().getName()+"使用Lambda表达式创建该线程")).start();

可以看出来明显代码变得优雅简洁了很多

Lambda表达式无参数无返回值

先定义一个Singer接口，抽象方法为writeMusic

package Advanced.Lambda;

public interface Singer {
    void writeMusic();
}

案例

package Advanced.Lambda;
/*
    Lambda表达式无参无返回值
 */
public class Demo02Singer {
    public static void main(String[] args) {
        //使用匿名内部类
        sing(new Singer() {
            @Override
            public void writeMusic() {
                System.out.println("大家好我是Vae");
            }
        });
        //使用Lambda表达式
        sing(()-> System.out.println("大家好我是Vae(Lambda)"));
    }
    public static void sing(Singer singer){
        singer.writeMusic();
    }
}

Lambda表达式有参数有返回值

案例一：建立一个Person对象，将多个对象放在数组里，按照年龄进行升序排序输出

Person类

package Advanced.Lambda;

public class Person {
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

测试类

package Advanced.Lambda;

import java.util.Arrays;
import java.util.Comparator;

/*
    Lambda表达式有参数有返回值
    建立一个Person对象,按照的年龄进行升序排序
 */
public class Demo03Sort {
    public static void main(String[] args) {
        Person[] arr = {
          new Person("许嵩",34),
          new Person("徐良",33),
          new Person("汪苏泷",31)
        };
        //使用匿名内部类
        Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        
        //使用lambda表达式对数组arr按照年龄进行排序
        Arrays.sort(arr,(p1,p2)-> p1.getAge()- p2.getAge());
        //遍历arr数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

案例二：给定一个计算器(Calculator)接口，内含抽象方法calc可以将两个数字相加得到和值

先建立一个Calculator接口

package Advanced.Lambda;

public interface Calculator {
    int calc(int a,int b);
}

测试类

package Advanced.Lambda;
/*
    给定一个计算器(Calculator)接口,内含抽象方法calc可以将两个数字相加得到和值
 */
public class Demo04Calculator {
    public static void main(String[] args) {
       show(10, 20, (a, b)-> a+b);
    }
    public static void show(int a,int b,Calculator c){
        System.out.println(c.calc(a,b));
    }
}

Lambda表达式有参数无返回值

案例三：使用Lambda表达式遍历输出List集合

package Advanced.Lambda;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

/*
     使用Lambda表达式遍历输出List集合
 */
public class Demo05Lambda {
    public static void main(String[] args) {
        String[] arr={"许嵩","汪苏泷","徐良"};
        List<String> list = Arrays.asList(arr);
        //传统的遍历方式
        for (String s : list) {
            System.out.println(s);
        }
        //forEach()方法用于调用数组的每个元素，并将元素传递给回调函数。
        /*list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/
        //使用Lambda表达式遍历
        list.forEach(s -> System.out.println(s));
    }
}

案例四：使用Lambda表达式实现监听器

package Advanced.Lambda;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Demo07Lambda extends JFrame{
    JPanel p;
    JTextArea ta;
    JButton bt1,bt2;
    public Demo07Lambda(){
        super("Lambda 测试");
        p = new JPanel();
        ta = new JTextArea();
        bt1 = new JButton("传统方式");
        bt2 = new JButton("Lambda方式");
        //添加监听器
        //传统写法
        bt1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                ta.append("点击传统方式按钮\n");
            }
        });
        //使用Lambda表达式
        bt2.addActionListener(e -> ta.append("点击Lambda方式按钮\n"));
        this.add(ta);
        p.add(bt1);
        p.add(bt2);
        this.add(p, BorderLayout.SOUTH);
        this.setSize(600,600);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
        new Demo07Lambda().setVisible(true);
    }
}