lambda 学习

lambda

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

lambda 语法格式

(parameters) -> expression 或者 (parameters) -> {statements;}

lambda区分好左右各是什么。左边：参数，右边：表达式。

注意事项：

• 如果参数只有一个，可以不加圆括号
• 不需要声明参数类型，因为可以类型推断
• 如果只有一条语句，可以不加花括号
• 如果只有一条语句，编译器会自动将值返回；如果多条的话，需要手动return

lambda 所需支持

Lambda 表达式需要“函数式接口”的支持 ，

函数式接口

接口中只有一个抽象方法的接口，称为函数式接口。 可以使用注解 @FunctionalInterface 修饰 （可以检查是否是函数式接口，如果不是函数式接口则会编译不通过）

代码案例

package cn.alistarfeng.demo.lambda;

import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Comparator;
import java.util.function.Consumer;

/**
 * @Auther: alistarfeng
 * @Date: 2019/9/12 15:51
 * @Description: lambda  学习 (parameters) -> expression 或者 (parameters) -> {statements;}
 */
public class LambdaDemo {

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    /**
     * 语法格式1 ： 无参数，无返回值
     */
    @Test
    public void test1() {
        //原来的方式
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                logger.info("hello world");
            }
        };
        runnable.run();
        //lambda
        Runnable runnable1 = () -> logger.info("hello world 2");
        runnable1.run();
    }

    /**
     * 语法格式二 ：有一个参数，并且无返回值，（只有一个参数可省略括号）
     */
    @Test
    public void test2() {
        //原来的方式
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                logger.info(s);
            }
        };
        consumer.accept("hope");
        //lambda的方式
        Consumer<String> consumer1 = (str) -> logger.info(str);
        consumer1.accept("hope1");
        Consumer<String> consumer2 = str -> logger.info(str);
        consumer2.accept("hope2");
    }

    /**
     * 语法格式三：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句（需要使用花括号括起来 , 且有返回的值的时候必须加return）
     */
    @Test
    public void test3() {
        //原来的方式
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                logger.info("匿名内部类输出");
                return o1 - o2;
            }
        };
        logger.info("comparator: {}", comparator.compare(4, 3));

        //lambda
        Comparator<Integer> comparator2 = (x, y) -> {
            logger.info("Lambda输出");
            return x - y;
        };
        logger.info("comparator2: {}", comparator2.compare(4, 3));
    }

    /**
     * 语法格式四：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写
     */
    @Test
    public void test4(){
        //原来使用匿名内部类
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer x, Integer y) {
                return Integer.compare(x, y);
            }
        };
        logger.info("comparator: {}", com.compare(4, 3));

        //Lambda 表达式
        Comparator<Integer> com1 = (x, y) -> Integer.compare(x, y);
        logger.info("comparator2: {}", com.compare(4, 3));
    }

    
}

代码地址：https://github.com/alistarfeng/java-learning/tree/master/java8-demo

欢迎关注 alistarfeng