Lambda表达式

Lambda表达式

Lambda表达式概述

是JDK8开始后代一种新语法形式

作用：简化匿名内部类的代码写法

lambda表达式的简化格式

(匿名内部类被重写方法的形参列表)->{
	被重写方法的方法体代码
}

lambda表达式只能简化函数式接口的匿名内部类的写法形式

什么式函数式接口：首先必须是接口，其次接口中有且仅有一个抽象方法的形式

原因：因为只有一个方法，因此简化时不必通过方法名调用方法

示例

Comparator<Integer> com=(o1,o2)->Integer.compare(o1,o2);
int compare=com.compare(22,44);

—>

为lambda操作符，或叫箭头操作符

—>左边

lambda形参列表，也就是接口中的抽象方法的形参列表

—>右边

lambda体，也就是重写的抽象方法的方法体

Lambda表达式的语法

无参，无返回值

Runnable r1=new Runnable() {
	@Override
	public void run() {
		System.out.println("la");
	}
};
//使用Lambda表达式后
Runnable r2=()-> System.out.println("la");

有一个参数，无返回值

public static void main(String[] args) {

    Consumer<String> consumer=new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    consumer.accept("ha");
    Consumer<String> consumer1=(String s)->{
        System.out.println(s);
    };
}

参数的数据类型可以省略，因为可以由编译器推断得出，称为类型推断

public static void main(String[] args) {

    Consumer<String> consumer=new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    consumer.accept("ha");
    Consumer<String> consumer1=(String s)->{
        System.out.println(s);
    };
    //参数类型可以省略不写。
    Consumer<String> consumer2=(s)->{
        System.out.println(s);
    };
}

若只需要一个参数，参数的小括号也可以省

public static void main(String[] args) {

    Consumer<String> consumer=new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    consumer.accept("ha");
    Consumer<String> consumer1=(String s)->{
        System.out.println(s);
    };
    //参数类型可以省略不写。
    Consumer<String> consumer2=(s)->{
        System.out.println(s);
    };
    //如果只有一个参数，参数类型可以省略，同时()也可以省略。
    Consumer<String> consumer3=s->{
        System.out.println(s);
    };
}

有两个及其以上的参数，多条执行语句，并有返回值

public static void main(String[] args) {
    //普通写法
    Comparator<Integer> comparator1=new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        }
    };
    //lambda表达式
    Comparator<Integer> comparator2=(o1,o2)->{
        System.out.println(o1);
        System.out.println(o2);
        return o1.compareTo(o2);
    };
}

当Lambda体中只有一条语句时，return和大括号都可以省

public static void main(String[] args) {
    //普通写法
    Comparator<Integer> comparator1=new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1.compareTo(o2);
        }
    };
    //lambda表达式
    Comparator<Integer> comparator2=(o1,o2)-> o1.compareTo(o2);
}

Lambda表达式写法总结

参数类型可以省略不写

如果只有一个参数，参数类型可以省略，同时()也可以省略。

如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写,同时要省略分号！

如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时，如果这行代码是 return语句，必须省略return。

Lambda表达式的应用

实现集合遍历和排序

List<String> list=new ArrayList<>();
list.add("小百");
list.add("小1");
list.add("小2");
list.add("大3");
list.add("小4");
list.sort((o1, o2) -> o1.compareTo(o2));
list.forEach(s -> System.out.println(s));