Java Lambda表达式简单使用

引用来源：
1）https://www.runoob.com/java/java8-lambda-expressions.html
2）某破站视频学习

1. Lambda表达式使用引入

前置知识：java接口、多态；
当代码使用匿名子类对象的方式时，可以是用Lambda表达式来代替传统写法;在IDEA中，放鼠标在new Cal()上会提示Anonymous new Cal() can be replaced with lambda

Lambda引入例子

public class Program {
    public static void main(String[] args) {
        System.out.println("1.传统写法：实现接口方式*************");
        //1.1传统写法：
        MyCal myCal = new MyCal();
        //1.2使用多态写法：
        //Cal myCal=new MyCal();

        System.out.println(myCal.add(10, 60));

        System.out.println("2.传统写法：匿名子类的对象*************");
        //2.1知识点：
        // 1)接口不能实例化
        // 2)多态
        // 3)匿名子类的对象
        //2.2优化:
        // 1)使用匿名子类的对象方式，从JDK1.8开始可以改写 为 lambda写法
        //"Anonymous new Cal() can be replaced with lambda"
        Cal c = new Cal() {
            @Override
            public int add(int a, int b) {
                return a + b;
            }
        };
        System.out.println(c.add(10, 12));
    }
}

//接口
interface Cal {
    //抽象方法，可省略了 public abstract
    int add(int a, int b);

    //Interface abstract methods cannot have body
        /*int add1(){

        };*/
}

//1.传统写法：实现接口Cal
class MyCal implements Cal {

    @Override
    public int add(int a, int b) {
        return a + b;
    }
}

2. Lambda表达式语法

Lambda表达式函数，只有参数列表 和 方法体;

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

说明：
( )：用来描述参数列表
{ }：用来描述方法体
->：Lambda运算符，可以叫做 箭头符号 或者 goes to

Lambda 入门例子

public class Program1 {
    public static void main(String[] args) {
        /*
         * ():用来描述参数列表
         * {}：用来描述方法体
         * -> :Lambda 运算符，可以叫做箭头符号，或者goes to
         * */
        Cal c =(int a,int b)->{
            return a+b;
        };
        System.out.println(c.add(10, 20));//30
    }
    //接口
    interface Cal {
        int add(int a, int b);
    }
}

3. Lambda 表达式精简语法

• 参数类型可以省略
• 假如只有一个参数，()括号可以省略
• 如果方法体只有一条语句，{}大括号可以省略
• 如果方法体重唯一的语句是return返回语句，那省略大括号的同时，return也要省略

精简语法例子

public class Program1 {
    public static void main(String[] args) {
        //lambda 精简语法
        Cal c1 = (a, b) -> a * b;
        System.out.println(c1.add(4, 9));//36
    }

    //接口
    interface Cal {
        int add(int a, int b);
    }
}

4. 方法引用

有时候多个lambda表达式实现函数是一样的话，我们可以封装成通用方法，以便于维护；这是用可以用方法引用实现

• 语法是：对象::方法
• 假如是static方法，可以直接:类名::方法

public class MyReferences {
    public static void main(String[] args) {
        /**
         * 表达式实现函数是一样
         */
        //当修改的时候，每个Lambda都要修改
        MyIf myIf0 = (a, b) -> a * b;
        System.out.println(myIf0.doCount(10, 3));
        MyIf myIf1 = (a, b) -> a * b;
        System.out.println(myIf1.doCount(9, 4));

        /**
         * 方法引用实现方式
         */
        //当修改的时候，只需要修改方法引用里的方法即可
        MyTestOfReferences myTestOfReferences = new MyTestOfReferences();
        MyIf myIf2 = myTestOfReferences::testA;
        System.out.println(myIf2.doCount(7, 6));
        MyIf myIf3 = myTestOfReferences::testA;
        System.out.println(myIf3.doCount(4, 8));

    }
}

class MyTestOfReferences {
    public int testA(int a, int b) {
        return a * b;
    }
}

interface MyIf {
    int doCount(int a, int b);
}

总结例子：

public class Program2 {
    public static void main(String[] args) {
        MyTest myTest = new MyTest();
        Cal c1 = myTest::testA;
        System.out.println(c1.add(10, 6));//4
        Cal c2=MyTest::testB;
        System.out.println(c2.add(5, 7));//35
    }


    //接口,该接口也可以写Program2外
    interface Cal {
        int add(int a, int b);
    }
}

class MyTest {
    public int testA(int a, int b) {
        return a - b;
    }

    public static int testB(int a, int b) {
        return a * b;
    }
}

5. 构造方法引用

如果函数式接口的实现恰好可以通过调用一个类的构造方法来实现，那么就可以使用构造方法引用；

• 语法：类名::new

1）Dog.java类

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

    public Dog() {
        System.out.println("无参构造方法");
    }
    public Dog(String name, int age) {
        System.out.println("有参构造方法");
        this.name = name;
        this.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;
    }
    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Program3 {


    public static void main(String[] args) {
        //1. lambda传统写法
        DogService dogService = () -> {
            return new Dog();
        };
        //2. lambda精简写法
        DogService dogService1 = () -> new Dog();
        System.out.println(dogService.getDog());
       
        System.out.println("*************************");
        
        //3. lambda构造引用写法
        DogService dogService2 = Dog::new;
        System.out.println(dogService2.getDog());//Dog{name='null', age=0}
        System.out.println("*************************");
        DogService2 dogService21=Dog::new;
        System.out.println(dogService21.getDog("旺财", 2));//Dog{name='旺财', age=2}
    }

    //接口
    interface DogService {
        Dog getDog();
    }
    //接口
    interface DogService2 {
        Dog getDog(String name, int age);
    }

}

6. Lambda表达式练习

public class Program4 {
    public static void main(String[] args) {
        List<Dog> list = new ArrayList<>();
        list.add(new Dog("aa", 1));
        list.add(new Dog("bb", 4));
        list.add(new Dog("cc", 2));
        list.add(new Dog("dd", 9));
        list.add(new Dog("ee", 3));

        System.out.println("lambda表达式集合排序");
        //排序--升序
        list.sort((o1, o2) -> o1.getAge() - o2.getAge());
        System.out.println(list);

        System.out.println("lambda表达式遍历集合");
        list.forEach(System.out::println);
    }
}