1.匿名内部类

@Test
public void test01(){
    //匿名内部类
    Comparator<Integer> comparator = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return Integer.compare(o1,o2);
        }

        @Override
        public boolean equals(Object obj) {
            return false;
        }
    };
    //调用
    TreeSet<Integer> set = new TreeSet<>(comparator);
}

2.lambda表达式

@Test
public void test02(){
    // Lambda 表达式
    Comparator<Integer> comparator = (a, b) -> Integer.compare(a, b);

    TreeSet<Integer> set = new TreeSet<>(comparator);
}

3.基础语法

Lambda表达式的基础语法：Java8中引入了一个新的操作符”->“ 称为：箭头操作符或者lambda操作符

语法：

• 左侧 -> 右侧
• 左侧：lambda 表达式的参数列表
• 右侧：lambda 表达式中所执行的功能。即lambda体

1.语法格式一：无参数，无返回值

例：实现Runnable接口

@Test
    public void test1() {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("hello"+num);
            }
        };
        r.run();
        System.out.println("-----------------------------------");

        //lambda表达式
        Runnable runnable = () -> System.out.println("hello lambda！"+num);
        runnable.run();
    }

2 语法格式二：有一个参数，无返回值

@Test
    public void test2(){
        Consumer<String> con = (x)-> System.out.println(x);
        con.accept("hahahha");
    }

3.语法格式三：若只有一个参数，小括号可以省略不写

@Test
    public void test2(){
        Consumer<String> con = x-> System.out.println(x);
        con.accept("hahahha");
    }

4.语法格式四：有两个以上的参数，有返回值，并且Lambda体中有多条语句

@Test
    public void test3(){
        Comparator<Integer> com =(x,y)->{
            System.out.println("函数式接口");
            return Integer.compare(x,y);
        };
    }

5.语法格式五：Lambda体中只有一条语句 大括号和return都省略

@Test
    public void test4(){
        Comparator<Integer> com = (x,y)-> Integer.compare(x,y);

    }

6语法格式六：Lambda表达式的参数列表的数据类型可以省略不写，因为jvm编译器通过上下文推断出数据类型，即类型推断
举例同上

4.案例

案例一：调用 Collections.sort() 方法，通过定制排序 比较两个 Employee (先按照年龄比，年龄相同按照姓名比)，使用 Lambda 表达式作为参数传递

实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Employee {

    private Integer id;
    private String name;
    private Integer age;
    private double salary;
}

@Test

public class study01 {
    List<Employee> emps = Arrays.asList(
            new Employee(101,"zhangsan",19,3333.33),
            new Employee(102,"zhangsan1",20,5555.55),
            new Employee(104,"zhangsan2",30,6666.66),
            new Employee(105,"zhangsan3",50,8888.88)
    );

    @Test
    public void test01(){
        Collections.sort(emps,(e1,e2)->{
            if (e1.getAge()==e2.getAge()){
                return e1.getName().compareTo(e2.getName());
            }else{
                return Integer.compare(e1.getAge(),e2.getAge());
            }
        });

        for(Employee emp:emps){
            System.out.println(emp);
        }
    }
}

运行结果:

Employee(id=101, name=zhangsan, age=19, salary=3333.33)
Employee(id=102, name=zhangsan1, age=20, salary=5555.55)
Employee(id=104, name=zhangsan2, age=30, salary=6666.66)
Employee(id=105, name=zhangsan3, age=50, salary=8888.88)