Lambada表达式

package com.wcs.demo1;


/**
 * 不使用Lambda表达式
 */
public class MyRunable {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        MyRunableImpl run = new MyRunableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类
        Thread t = new Thread(run);
        //调用start方法，开启新线程，执行run方法
        t.start();

        //简化代码，使用匿名内部类，实现多线程
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "新的线程创建了");
            }
        };
        new Thread(r).start();

        //简化代码
        Thread tt = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "新的线程创建了");
            }
        });
        tt.start();
    }
}

1、体验Lambda的更优写法

package com.wcs.demo1;

/**
 * 匿名内部类和lambda表达式
 */
public class LambdaTest01 {
    public static void main(String[] args) {
        //使用匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "新的线程创建了");
            }
        }).start();

        //使用lambda表达式，实现多线程
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "新的线程创建了");
        }).start();
    }
}

以上代码中，Runnable接口只有一个run方法的定义：

public abstract void run();

制定一种做事情的方案（其实就是一个函数）：

• 无参数：不需要任何条件即可执行该方案；
• 无返回值：该方案不产生任何结果；
• 代码块：该方案的具体执行步骤。

同样的语义体现在Lambda语法中，更加简单：

()->System.out.println("多线程任务执行")。

• 前面的小括号即run方法，的参数（无），代表不需要任何条件；
• 中间的一个箭头代表前面的参数传递给后面的代码；
• 后面的输出语句即业务逻辑代码。

2、排序实例

2.1、数组排序

package com.wcs.demo1;

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

/**
 * @author wcs
 * @create 2021-08-20 11:18
 */
public class Array1 {
    public static void main(String[] args) {
        int[] nums = new int[]{0, 23, 3, 1, 3, 68, 44, 2};
        System.out.println(Arrays.toString(nums));
        Arrays.sort(nums);//升序排列
        System.out.println(Arrays.toString(nums));

        Integer[] nums2 = new Integer[]{0, 23, 3, 1, 3, 68, 44, 2};
        Arrays.sort(nums2);//升序
        System.out.println(Arrays.toString(nums2));
        Arrays.sort(nums2, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(Arrays.toString(nums2));//降序

        //使用lambda表达式排序
        Arrays.sort(nums2, (a, b) -> b - a);
        System.out.println(Arrays.toString(nums2));//降序
    }
}

2.2、字符串排序

package com.wcs.demo1;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

/**
 * @author wcs
 * @create 2021-08-20 12:41
 */
public class StringSort {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("java","B","go","C++","php"));
        //未排序
        System.out.println(list);
        //使用匿名内部类自然升序
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println(list);
        //使用Lambda表达式自然升序
        list.sort((a,b)->b.compareTo(b));
        System.out.println(list);
        //使用Lambda表达式，按字符串个数降序
        list.sort((a,b)->b.length()-a.length());
        System.out.println(list);
    }
}

2.3、对象排序

package com.wcs.demo1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/**
 * @author wcs
 * @create 2021-08-20 11:44
 */
public class ObjectSort {
    public static void main(String[] args) {
        Student stu1 = new Student(001, "jack", 18);
        Student stu2 = new Student(004, "rose", 20);
        Student stu3 = new Student(007, "mike", 12);
        ArrayList<Student> list = new ArrayList<>();
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        //使用匿名内部类，对学生id进行降序
        list.sort(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o2.getId() - o1.getId();
            }
        });
        for (Student s : list) {
            System.out.println(s);
        }
        //Lambda表达式，对学生年龄降序
        list.sort((a, b) -> b.getAge() - a.getAge());
        for (Student s : list) {
            System.out.println(s);
        }
        //Lambda表达式，对学生姓名排序
        list.sort((a,b)->b.getName().compareTo(a.getName()));
        for (Student s :list){
            System.out.println(s);
        }
    }
}

class Student {
    private int id;
    private String name;
    private int age;

    public Student() {

    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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;
    }

    @Override
    public String toString() {
        return "Student[" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ']';
    }
}

3、Lambda的使用前提

1. 使用Lambda必须具有接口，且要求接口中有且只有一个抽象方法；
2. 使用Lambda必须具有上下文推断；（也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例）

备注：有且只有一个抽象方法称为函数式接口