【JAVA学习之路 | 进阶篇】Lambda表达式

public class LambdaTest {
    public static void main(String[] args) {
        //实现线程当中提及的Runnable接口,重写了当中的一个抽象方法, 并创建了匿名实现类的对象
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("hexua你太酷啦");
            }
        };
        r1.run();
 
        //如果我们使用lambda表达式,将会非常简洁
        Runnable r2 = () -> {
            System.out.println("hexua你太酷啦");
        };
        r2.run();
        //运行会发现,两种写法运行结果相同
        //hexua你太酷啦
        //hexua你太酷啦
    }
}

@Test
    public void test1() {
        //无参数, 无返回值类型
        Runnable r1 = () -> {
            System.out.println("语法格式-1");
        };
        r1.run();
        //输出和 : 语法格式-1
    }

@Test
    public void test2() {
        //需要一个参数, 但没有返回值
        LambdaInterface<String> l1 = (String s) -> {
            System.out.println(s + "tkl");
        };
        l1.show("hexua");
        //输出 : hexuatkl
    }
}
interface LambdaInterface<T> {
    void show(T s);
}

@Test
    public void test3() {
        //类型推断, String类型可以省略
        LambdaInterface<String> l1 = (s) -> {
            System.out.println(s + "tkl");
        };
        l1.show("hexua");
        //输出 : hexuatkl
    }
}
interface LambdaInterface<T> {
    void show(T s);
}

@Test
    public void test4() {
        //参数列表只有一个参数的情况下, 圆括号也可以不写
        LambdaInterface<String> l1 = s -> {
            System.out.println(s + "tkl");
        };
        l1.show("hexua");
        //输出 : hexuatkl
    }
}
interface LambdaInterface<T> {
    void show(T s);
}

@Test
    public void test5() {
        LambdaInterface<String> l1 = (s, t) -> {
            System.out.println("我也不知道这里写什么");
            return s + "你过来啊" + t;
        };
        System.out.println(l1.show("hexua", "hexi"));
        //输出 : 我也不知道这里写什么
        //hexua你过来啊hexi
    }
}
interface LambdaInterface<T> {
    String show(T s, String t);
}

@Test
    public void test6() {
        //只有一条语句时, return与大括号若有, 都可以省略
        LambdaInterface l2 = () -> "return与大括号都可以省略";//返回值语句
        System.out.println(l2.show());
        //输出 : return与大括号都可以省略
    }
}
interface LambdaInterface<T> {
    String show();
}

Consumer<T>
抽象方法 : void accept(T t)

Supplier<T>
抽象方法 : T get()

Function<T, R>
抽象方法 : R apply(T t)

Predicate<T>
抽象方法 : boolean test(T t)