很适合装逼的代码(Lambda表达式)

Lambda表达式概述：

     Lambda表达式是JDK1.8开始之后的新技术，是一种代码的新语法，是一种特殊写法。
     作用：“核心目的是为了简化匿名内部类的代码写法”。

Lambda表达式的格式:

    (匿名内部类被重写方法的形参列表) -> {
       被重写方法的方法体代码。
    }
     -> 就是一个新语法，没有实际含义，但是不能省略！

Lambda表达式的使用前提：

    a.首先必须是接口。
    b.接口中只能有一个抽象方法。 
    c.@FunctionalInterface函数式接口注解：
    一旦某个接口加上了这个注解，这个接口只能有且仅有一个抽象方法， 这个接口就可以被Lambda表达式简化。

举例：Lambda表达式简化Runnable接口的匿名内部类写法

public class LambdaDemo {
    public static void main(String[] args) {
    	//不使用Lambda表达式
        Runnable target = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() +"---->执行！");
            }
        };
        Thread t = new Thread(target);
        t.start();

		//使用Lambda表达式 
        Runnable target1 = () -> {
            System.out.println(Thread.currentThread().getName() +"---->执行！");
        };
        Thread t1 = new Thread(target1);
        t1.start();

		//匿们类继续简化
        new Thread(() -> {
                System.out.println(Thread.currentThread().getName() +"---->执行！");
        }).start(); 
    }
}

执行效果：

Lambda表达式进一步在Lambda表达式的基础上继续简化

（1）如果Lambda表达式的方法体代码只有一行代码，可以省略大括号不写，同时要省略分号！
（2）如果Lambda表达式的方法体代码只有一行代码，可以省略大括号不写，此时，如果这行代码是return语句，必须省略return不写，同时也必须省略";"不写。
（3）参数类型可以省略不写。
（4）如果只有一个参数，参数类型可以省略，同时()也可以省略。

举例：Lambda简化Comparator接口匿名内部类写法

public class CollectionsDemo{
	public static void main(String[] args){
		//创建集合存储学生对象
		List<Student> students = new ArrayList<>();
		
		//添加学生对象
		students.add(new Student("李四",24,'女'));
		students.add(new Student("赵六",26,'女'));
		students.add(new Student("王五",25,'男'));
		students.add(new Student("张三",23,'男'));
	
		//使用 Collections.sort方法对学生对象集合根据年龄大小升序
		//不适用Lambda表达式
		Collections.sort(students , new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        //使用Lambda表达式进行简化
        // 简化一
        Collections.sort(students , (Student o1, Student o2) -> {
              return o1.getAge() - o2.getAge();
        });

        // 简化二
        Collections.sort(students , (Student o1, Student o2) ->  o1.getAge() - o2.getAge());

        // 简化三
        Collections.sort(students , ( o1,  o2) ->  o1.getAge() - o2.getAge());
		//遍历集合，查看效果
		for (Student student : students) {
            System.out.println(student);
        }
	}
}
class Student {
    private String name ;
    private int age ;
    private char sex ;

    public Student() {
    }

    public Student(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
}

运行效果：

注意：Lambda表达式是简化匿名内部类的写法，但是只能简化函数式接口。