Lambda表达式

1. 函数式编程的思想

只注重:输入量,计算方法,输出量这三个方面,而不注重形式的一种新的编程思想

2 .冗余的Runnable代码

需求:使用实现方式创建一个线程
public class TestDemo {
    public static void main(String[] args) {
        //使用实现方式创建一个线程
        new Thread(new Runnable() {

            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了...");
            }
        }).start();
    }
}    

缺点:
a.为了不写一个实现类,我们不得不被逼的采用匿名内部类
b.由于面向对象语法的束缚,我们不得不被逼的只能创建Runnable的匿名内部类
c.由于面向对象语法的束缚,我们不得不被逼的从写一个和run一模一样的方法
d.似乎只有方法体才是我们想要的心甘情愿写的
以上我们称为面向对象的冗余代码

3. 函数式编程Lambda的体验

 new Thread(()->{System.out.println(Thread.currentThread().getName()+"执行了...");}).start();

使用函数式编程思想,大大简化面向对象语法
函数编程思想只关注三个方面: 输入量(参数) 计算方法(方法体) 输出量(返回值)

4. Lambda标准格式介绍

Lambda表达式(函数式编程)可以用于替代接口的匿名内部类
格式:
(方法参数)->{方法体;return 返回值;}

比如:
new Thread(()->{System.out.println(“执行了…”);}).start();

5. Lambda的参数和返回值

public class LambdaDemo {
    public static void main(String[] args) {
        //1.练习1
        //比较器排序
        Integer[] arr = {445,345,346,45,764,576,5,76,8};
        //使用面向对象的匿名内部类
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //降序
                return o2 - o1;
            }
        });
        //使用Lambda替代上面Comparator接口的匿名内部类
        Arrays.sort(arr,(Integer o1, Integer o2)->{return o2 - o1;});
        System.out.println(Arrays.toString(arr));
        System.out.println("=====================");
        //2.练习2
        Student[] students = new Student[4];
        students[0] = new Student("jack",10,98);
        students[1] = new Student("tom",12,90);
        students[2] = new Student("marry",15,80);
        students[3] = new Student("hanmeimei",18,20);
        //排序
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
               //按照学生的名字的长度降序
               return o2.getName().length() - o1.getName().length();
            }
        });
        //使用lambda替代上面的匿名内部类
        Arrays.sort(students,(Student o1, Student o2)->{return o2.getName().length() - o1.getName().length();});

        for (Student stu : students) {
            System.out.println(stu);
        }
    }
}

6. Lambda的省略格式

Lambda还有三个地方可以省略:
a.参数的数据类型可以省略
b.如果参数只有一个,那么小括号也可以省略
c.如果{}中方法体和返回值语句可以写成一句代码,那么{},return关键字,以及后面的分号可以同时省略

• 案例1:

	 //标准格式
    new Thread(()->{System.out.println("执行了...");}).start();
    //省略格式
    new Thread(()->System.out.println("执行了...")).start();

• 案例2:

	 //标准格式 
    Arrays.sort(arr,(Integer o1, Integer o2)->{return o2 - o1;});
    //省略格式
    Arrays.sort(arr,(o1,o2)->o2 - o1);

• 案例3:

	//标准格式
    Arrays.sort(students,(Student o1, Student o2)->{return o2.getName().length() - o1.getName().length();});
    //省略格式
    Arrays.sort(students,(o1, o2)->o2.getName().length() - o1.getName().length());

7. 强烈注意:Lambda的使用前提

a.“只有"函数式接口的匿名内部类才能用Lambda来替换!!!
所谓函数式接口是指有且仅有一个抽象方法的接口(别的方法个数不限)
b.Lambda只有以上三种情况的省略格式,因为Lambda有一个"可推导才可省略”!