Lambda表达式

Lambda表达式

1.函数式编程思想

面向对象的思想:

​ 做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.

函数式编程思想:

​ 只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程

2.Lambda表达式

2.0Lamdda表达式的标准格式

Lambda表达式的标准格式：
    由三部分组成：
        1.一些参数
        2.一个箭头
        3.一段代码
    格式：
        （参数列表）->{一些重写方法的代码}
    解释说明：
        ():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔
        ->:传递的意思,把参数传递给方法体{}
        {}:重写接口的抽象方法的方法体

public class Demo01Lambda {
    public static void main(String[] args) {

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

        //使用lambda表达式实现多线程
            /*
            因为Thread中传递的对象就是Runnable
                public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);}

            所以就可以知道lambda重写的是Runnable中的run方法
            */
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+" 新线程创建了");

        }).start();

        //Lambda优化省略
        new Thread(()-> System.out.println(Thread.currentThread().getName()+" 新线程创建了")).start();

    }
}

2.1Lambda表达式无参无返回值的练习

需求:
    给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数、无返回值。
    使用Lambda的标准格式调用invokeCook方法，打印输出“吃饭啦！”字样

public class Demo01Cook {
    public static void main(String[] args) {

        //匿名内部类
       invokeCook(new Cook() {
           @Override
           public void makeFood() {
               System.out.println("做饭");
           }
       });

        //lambda表达式，简化匿名内部类
        invokeCook(()->{
            System.out.println("做饭");
        });
    }

    //定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
    public static void invokeCook(Cook cook){
        cook.makeFood();
    }
}

定一个厨子Cook接口，内含唯一的抽象方法makeFood

public interface Cook {
    //定义无参数无返回值的方法makeFood
    public abstract void makeFood();
}

2.2Lambda表达式有参数有返回值的练习

Lambda表达式有参数有返回值的练习
需求:
    使用数组存储多个Person对象
    对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序

使用lambda表达式重写了Comparator接口中的比较方法，替代匿名内部类的方式

public class Demo01Arrays {
    public static void main(String[] args) {

        Person[] arr={
                new Person("迪丽热巴",21),
                new Person("古力娜扎",28),
                new Person("唐艺昕",24),
        };

        //对数组中的Person对象使用Arrays的sort方法通过年龄升序（前面-后面）排序
       /* Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });*/

        //通过lambda表达式表示
        Arrays.sort(arr,(Person o1,Person o2)->{
            return o2.getAge()-o1.getAge();
        });

        for (Person person : arr) {
            System.out.println(person);
        }


    }
}

Person类

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

Lambda表达式有参数有返回值的练习
需求:
    给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
    使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算

public class Demo01Calculator {
    public static void main(String[] args) {
        //调用invokeCalc方法,方法的参数是一个接口,可以使用匿名内部类
        invokeCalc(120, 130, new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a + b;
            }
        });

        //调用invokeCalc方法,传入两个int类型参数，再使用lambda表达式重写接口的抽象方法
        invokeCalc(120, 130, (int a,int b) -> {
            return a + b;
        });

        //优化省略lambda 只有一行代码，所以可以省略{}，return，分号
        invokeCalc(120,130,(a,b)-> a + b);

    }



    public static void invokeCalc(int a ,int b,Calculator calculator){
        int calc = calculator.calc(a, b);
        System.out.println(calc);
    }
}

Calculator抽象接口

/*
    给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
 */
public interface Calculator {
    public abstract int calc(int a,int b);
}

2.4Lambda优化省略

Lambda表达式：是可推导，可以省略
凡是根据上下文推到出来的内容，都可以省略书写
可以省略的内容：
   1（参数列表）：括号中参数列表的类型可以省略不写
   2（参数列表）：如果括号中只有一个参数，那么类型和（）都可以省略
   3{一行代码}：如果{}中只有一行代码，无论是否有返回值，都可以省略（{}，return，分号）
注意：
   {}，return，分号要省略必须一起省略

public class Demo01ArrayList {
    public static void main(String[] args) {
        //jdk1.7之前，创建集合对象必须把前后的泛型都写上
        ArrayList<String> strings = new ArrayList<String>();

        //jdk1.7以后，=后面的泛型可以省略，因为可以根据前面推到出来
        ArrayList<String> strings1 = new ArrayList<>();

    }

}

tip：

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