java lambda表达式

格式

Comparator<Integer> comparator1 = (o1,o2) -> Integer.compare(o1,o2);

等价于

Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };

解释

-> ：lambda操作符（箭头操作符）

->左边：lambda形参列表（其实就是接口中的抽象方法的形参列表）

->右边：lambda体（其实就是重写的抽象方法的方法体）

Lambda表达式的本质：作为函数式接口的实例(即对象)

函数式接口：如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。使用注解@FunctionalInterface注释

总结

->左边：

• lambda形参列表的参数烈性可以省略（类型推断）
• 如果lambda形参列表只有一个参数，其()也可以省略
  • 如果没有参数，或者参数有1个以上，则不能省

->右边

• lambda体应该使用一堆{}包裹；
• 如果lambda体只有一条执行语句（可能是return语句），可以省略这一对{}和return关键字

package lambda;

import org.junit.Test;

/**
 * @author Alvin
 * @version 1.0
 * @createDate 2023/10/13 11:19
 */
public class lambdaDemo1 {

    @Test
    public void test1(){
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("这是new Runnable()");
            }
        };

        runnable.run();


        Runnable runnable1 = () -> System.out.println("这是lambda");
        runnable1.run();


    }
}

package lambda;

import org.junit.Test;

import java.util.function.Consumer;

/**
 * @author Alvin
 * @version 1.0
 * @createDate 2023/10/13 11:23
 */
public class Demo2 {

    @Test
    public void test2(){
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("new Consumer<String>() s ： " + s);
            }
        };
        consumer.accept("hello，你好呀，骚年");


        Consumer<String> consumer1 = s -> System.out.println("lambda表达式 s : " + s);
        consumer1.accept("hello，你好呀，骚年");

    }
}

package lambda;

import org.junit.Test;

import java.util.Comparator;

/**
 * @author Alvin
 * @version 1.0
 * @createDate 2023/10/13 11:26
 */
public class Demo3 {

    @Test
    public void test3(){

        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };

        System.out.println(comparator.compare(1,2));

        //lambda表达式写法
        Comparator<Integer> comparator1 = (o1,o2) -> Integer.compare(o1,o2);
        System.out.println(comparator1.compare(2,1));

        //方法引用
        Comparator<Integer> comparator2 = Integer :: compare;
        System.out.println(comparator2.compare(0,0));
    }
}

package lambda;

import org.junit.Test;

import java.util.function.Consumer;

/**
 * @author Alvin
 * @version 1.0
 * @createDate 2023/10/13 11:35
 */
public class Demo4 {

    @Test
    public void test4(){

        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("new Consumer<String>() s ： " + s);
                System.out.println("初次见面，多多关照哦～");
            }
        };
        consumer.accept("hello，你好呀，骚年");


        Consumer<String> consumer1 = s -> {
            System.out.println("lambda表达式 s : " + s);
            System.out.println("初次见面，多多关照哦～");
        };
        consumer1.accept("hello，你好呀，骚年");
    }
}