Java8-Lambda 表达式入门

只能应用于函数式接口，Lambda表达式可以认为是一种特殊的匿名内部类

Lambda 语法

参数说明：

• () :参数列表，不需要参数的类型，会自动推断
• -> :连接符
• {} :表示方法体

([形参列表，不带数据类型]) -> {
  //执行语句
  [return ...;]
}

注意点：

• 如果形参列表是空的，只需要保留()即可。
• 如果没有返回值，只需要在{}写执行语句即可。
• 如果接口的抽象方法只有一个形参，()可以省略，值需要参数的名称即可。
• 如果执行语句只有一行，可以省略{}，但是如果有返回值的时候，有点特殊。
• 形参列表的数据类型自动推断，只要参数名称。
• 如果函数式接口的方法有返回值，必须给定返回值，如果执行语句只有一行代码，可以省略大括号，但必须同时省略return。
• 和匿名内部类一样，如果访问局部变量，要求局部变量必须是final的。

多说无益，写一个简单的Lambda的Demo

创建关闭的接口

/**
 * 关闭接口
 */
public interface Closeable {
    void close();
}

编写main函数

class CloseDoor {

    /**
     * 关门
     * @param c
     */
    public void doClose(Closeable c) {
        c.close();
    }

    public static void main(String[] args) {
        CloseDoor cd = new CloseDoor();
        cd.doClose(new Closeable() {
            @Override
            public void close() {
                System.out.println("使用匿名内部类!");
            }
        });

        cd.doClose(() -> System.out.println("使用Lambda实现"));
    }

}

再来一个简单的Lambda的Demo

public interface LambdaReturn {
    int test();
}

class TestLambdaReturn {
    void re(LambdaReturn lr){
        int i = lr.test();
        System.out.println("Lambda表达式返回的值:" + i);
    }

    public static void main(String[] args) {
        TestLambdaReturn tlr = new TestLambdaReturn();
        tlr.re( () -> {return 14;});

        // 如果需要return，但只有一句，可以省略大括号，但是必须同时省略return关键字
        // 有return的时候不建议省略大括号
        tlr.re(() -> 14);
    }
}

更多实例说明

声明函数式接口

/**
 * 函数式接口，没有参数，没有返回值
 */
@FunctionalInterface
interface UserTest {
    void test();
}

/**
 * 带一个参数的函数式接口
 */
@FunctionalInterface
interface UserTest1 {
    void test(int i);
}

/**
 * 带两个参数的函数式接口
 */
@FunctionalInterface
interface UserTest2 {
    void test(int i, int j);
}

/**
 带一个参数有返回值的接口
 */
@FunctionalInterface
interface UserTest3 {
    int test(int i);
}

Main方法测试

/**
 * TestLambda类
 */
public class TestLambda {

    public static void main(String[] args) {

        // 使用匿名内部类实现,在Java8之前，没有Lambda表达式
        UserTest ut = new UserTest(){
            public void test() {
                System.out.println("使用匿名内部类实现!");
            }
        };
        // 调用
        ut.test();

        // () :参数列表，不需要参数的类型，会自动推断
        // -> :连接符
        // {} :表示方法体
        UserTest ut1 = () -> {
            System.out.println("使用没有Lambda表达式实现 ");
        };
        ut1.test();

        // 如果方法体只有一句话，可以省略大括号以及省略一个分号。
        // 如果有返回值，连return 也可以省略。
        UserTest ut2 = () -> System.out.println("使用最简化的Lambda表达式实现 ");
        ut2.test();

        int i = 100;
        // 圆括号里面只需要知道参数的名称，不需要参数的类型。
        // 数据类型自动根据函数式接口的定义推断
        UserTest1 ut3 = (x) -> {
            System.out.println("一个参数，一行代码输出参数的值:" + x);
        };
        ut3.test(i);

        // 如果参数列表里面，只有一个参数，可以省略圆括号
        UserTest1 ut4 = x -> System.out.println("一个参数，一行代码输出参数的值:" + x);
        ut4.test(i);

        UserTest2 ut5 = (x, y) -> {
            System.out.println("两个参数x:" + x);
            System.out.println("两个参数y:" + y);
        };
        ut5.test(5,29);

        UserTest3 ut6 = (b) -> {
          b = b + 10;
          return b;
        };
        int o = ut6.test(15);
        System.out.println(o); // 25

        // 如果省略了大括号，return一定要省略掉
        // 代码里面的表达式返回值会自动作为方法的返回值
        UserTest3 ut7 = b -> b + 10;
        int o1 = ut7.test(13);
        System.out.println(o1); //23

    }

}