Lambda 表达式

这里用了我老师的笔记

Lambda 表达式
面向对象思想:
​ 做一件事情,找一个能够解决这个事情的对象,调用对象的方法来完成这件事情
函数式编程思想:
​ 重视的是结果,怎么做事情,不重视完成的过程,找谁来做
Lambda表达式作用:简化匿名内部类

lambda表达式使用前提:必须有接口,接口中有且只能有一个抽象方法(函数式接口)

Lambda表达式是可推导,可省略:能推导出来,Lambda表达式重写的就是接口中唯一的抽象方法

• (参数列表):重写抽象方法的参数
• ->:传递(固定写法):可以把参数传递到方法体中使用
• {}:重写抽象方法的方法体
• Lambda表达式的语法(重点)==>基本使用格式
  ( )->{ } public abstract void run();
  一些参数,一个箭头,一些代码
  ():重写接口中唯一的抽象方法的参数列表,没有参数就空着,有多个参数使用逗号隔开
  ->:传递,可以把参数()传递给{ }方法体使用
  { }:重写接口中唯一抽象方法的方法体
  Lambda表达式的使用前提:
  1.必须有接口
  2.接口中有且只能仅有一个抽象方法(函数式接口)
  注意:
  Lambda表达式是可推导可省略
  Lambda表达式的目的就是重写接口中唯一的抽象方法
  接口中的抽象方法只有一个,可以推导出重写的就是接口唯一的这个抽象方法,所以代码才能使用lambda简化

下面用匿名实现Runnable多线程代码来做个实验 没有返回值

public class Demo {
    public static void main(String[] args) {	//这里可以看到 匿名内部类代码很多 比较繁琐
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("你好 多线程");
            }
        }).start();
        
        //下面使用Lambda表达式来简写
        //格式 (参数列表)->{重写抽象方法的方法体}
        new Thread(()-> { //其实这里还可以简写
            System.out.println("你好多线程");
        }).start();
        
        new Thread(()->System.out.println("你好多线程")).start();//这是最终简写的效果
    }
}

使用Lambda表达式重写有参数有返回值的方法
使用Lambda表达式重写有参数有返回值的方法(重点)
需求:
创建一个数组,数组的类型使用Person
创建3个Person对象,存储到数组中
使用数组工具类Arrays中的方法sort,根据比较器产生的规则对Person对象进行按照年龄升序排序

public class Demo02Lambda {
    public static void main(String[] args) {
        //创建一个数组,数组的类型使用Person
        Person[] arr = new Person[3];

        //创建3个Person对象,存储到数组中
        arr[0] = new Person("张三",18);
        arr[1] = new Person("李四",20);
        arr[2] = new Person("王五",19);
        System.out.println("排序前数组中的元素:"+Arrays.toString(arr));

        //使用数组工具类Arrays中的方法sort,根据比较器产生的规则对Person对象进行按照年龄升序排序
        Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                //升序:o1-o2  降序:o2-o1
                return o1.getAge()-o2.getAge();
            }
        });
        System.out.println("排序后数组中的元素:"+Arrays.toString(arr));

        //使用Lambda表达式简化匿名内部类 public int compare(Person o1, Person o2)
        Arrays.sort(arr,(Person o1, Person o2)->{
            return o2.getAge()-o1.getAge();//降序
        });
        System.out.println("排序后数组中的元素:"+Arrays.toString(arr));
        //下面来写最终简写效果
        Arrays.sort(arr, (Person o1, Person o2)-> o1.getAge() - o2.getAge()); //如果参数只有一个的话 可以省略小括号
    }
}
class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}