java-Lambda表达式

Lambda表达式

基础知识

• 面向对象思想，做一件事，找一个可以解决这件事的对象，调用对象方法，完成事件
• 函数式思想编程，只要能获取结果，怎么做谁去做，都不重要，重视结果，不重视过程

package lambdaText;
/*
    Lambda表达式的标准写法
        三部分组成
            1.一些参数
            2.一个箭头
            3.一段代码
        格式
            (参数列表) -> {方法体}
        格式说明
            (),接口中抽象方法的参数列表，没有就空着，有参就写，多参逗号分隔
            ->，传递的意思，把参数传递给方法体
            {}，重写接口中抽象的方法体
*/
public class Demo01Lambda {
    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();
    }
}

• 匿名内部类
  • 可以帮我们省去类的定义
  • 语法复杂

无参无返回值练习

package lambdaText;
/*
    需求
        给定一个厨子cook接口，内含唯一抽象方法makecook，且无参无返回值
        使用Lambda表达式，invokecook方法，打印“吃饭”
*/
public class Demo02 {
    public static void main(String[] args) {

        //调用invokeCook方法，参数是Demo02Text接口，传递接口中的匿名内部类对象
        invokeCook(new Demo02Text() {
            @Override
            public void makeFood() {
                System.out.println("吃饭了");
            }
        });
        //使用Lambda表达式简化
        invokeCook(() ->{
            System.out.println("吃饭了");
        });
    }
    //定义一个方法传递Demo02Text接口，方法内部调用Demo02Text内部的方法makeFood方法
    public static void invokeCook(Demo02Text cook){
        cook.makeFood();
    }
}

有参数有返回值

package lambdaText;

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

/*
    lamvda表达式，有参有返回值
        1.使用数组储存多个Person对象
        2.对储存的对象使用Array中的sort方法进行年龄生序排列
*/
public class Demo03 {
    public static void main(String[] args) {
        //1.使用数组储存多个Person对象
        Demo03Person[] arr={
                new Demo03Person("热巴",18),
                new Demo03Person("娜扎",19),
                new Demo03Person("穷哈",17)
        };
        //2.对储存的对象使用Array中的sort方法进行年龄生序排列
     /*   Arrays.sort(arr, new Comparator<Demo03Person>(){
            @Override
            public int compare(Demo03Person o1, Demo03Person o2) {
                return o1.getAge()-o2.getAge();//升序前减后
            }
        });*/

        //使用Lambda方式，简化匿名内部类
        Arrays.sort(arr, (Demo03Person o1, Demo03Person o2)-> {
                return o1.getAge()-o2.getAge();//升序前减后
            }
        );
        for (Demo03Person demo03Person : arr) {
            System.out.println(demo03Person);
        }
    }
}

有参数有返回值,自定义接口

package lambdaText;
/*
    lamvda表达式，有参有返回值
        1.给定计算器calculator接口，内含抽象方法cala将两个int数加和
        2.使用Lambda表达式invokecala，计算相应题目
*/

public class Demo04 {
    public static void main(String[] args) {
        invokecala(100, 100, new Calaulator() {
            @Override
            public int cala(int a, int b) {
                return a+b;
            }
        });

        //使用Lambda
        invokecala(100,200,(int a,int b)->{
            return a+b;
        });
    }
    /*
        定义一个方法
        参数传递两个int数
        参数传递Calculator接口
        方法中调用Calculator接口中的方法cala，计算和
    */
    public static void invokecala(int a,int b,Calaulator c){
        int sum = c.cala(a, b);
        System.out.println(sum);
    }
}

Lambda表达式使用前提

• 使用Lambda表达式，必须具有接口，且要求接口中有且只有一个抽象方法
• 使用Lambda表达式，必须具有上下文推断
• 有且只有一个抽象方法接口，称为函数式接口

package lambdaText;

import java.util.Arrays;

/*
    Lambda表达式，可推到，可省略
    凡根据上下文推导出来的内容，都可以省略
    可以省略的内容
        1.(参数列表)，括号中参数列表中的数据类型可以不写
        2.(参数列表)，括号中的参数只有一个，可以不写括号()
        3.{一些代码}，如果括号中的代码只有一行，无论是否有返回值，都可以省略（{}，return，分号（;））
            注意，要省略{}，return，分号（;）必须一起省略
*/
public class Demo05 {
    //使用Lambda表达式简化
    invokeCook(() ->{
        System.out.println("吃饭了");
    });
    //继续省略
    invokeCook(() -> System.out.println("吃饭了")
    );

    //使用Lambda方式，简化匿名内部类
        Arrays.sort(arr, (Demo03Person o1, Demo03Person o2)-> {
        return o1.getAge()-o2.getAge();//升序前减后
    }
        );
    //继续省略
          Arrays.sort(arr, (o1,o2)-> o1.getAge()-o2.getAge()//升序前减后
        );

}