玩转java8 Lambda表达式一

Lambda表达式是对象，是一个函数式接口的实例，普通接口不能使用Lambda表达式。若想了解Lambda表达式及函数式接口介绍，请移步进行学习Java8 lambda表达式及自定义函数式接口入门。

Lambda 表达式语法

(lambda paramters) -> lambda expression;

小括号()：代表方法签名，当只有一个参数的时候，（）可以省略
lambda paramters：代表具体形参，参数可以指定类型也可以省略类型，因为Lambda表达式会自动推断出参数类型
->：代表lambda操作符
lambda expression：代表lambda表达式body体，具体的函数式接口唯一方法实现逻辑。当body体只有一行代码的时候，{}和return都可以省略

Lambda 表达式练习

要点：一看参数，二看返回值
\`
错误示例：

参数类型要么全部省略，不能省略部分，如 (x, int y) -> x+y;
参数不能使用final修饰，如(final a)->a;
函数表达式接口不能返回一个Object对象，如Object obj = () -> "lambda";
不允许使用throws语句来声明它可能会抛出的异常,只能在方法上抛出异常，如
@Test
public void testCallable() throws Exception{
Callable callable = ()->{return 1;};
callable.call();
}
\`
无参无返回值

/**
 * 无参无返回值
 */
@Test
public void testNoArgsNoReturn(){
    /**
     * 当大括号{}包括多行执行语句，则{}不能省略
     */
    Runnable t1 = () -> {
        System.out.println("t1 running...");
        System.out.println("t1 run ended.");
    };
    /**
     * 当大括号{}只有一行执行语句，则{}可以省略，如下写法都正确
     */
    Runnable t2 = () -> {System.out.println("t2 running...");};
    Runnable t3 = () -> System.out.println("t3 running...");
    /**
     * 当没有任何实现语句时，{}需要保留
     */
    Runnable t4 = () -> {};
    new Thread(t1).start();
    new Thread(t2).start();
    new Thread(t3).start();

    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
    }
}

无参，有返回值

/**
 * 测试无参，有返回值
 */
@Test
public void testNoArgsReturn() {
    /**
     * 当大括号{}包括多行执行语句，则{}不能省略
     */
    Supplier<String> s1 = () -> {
        System.out.println("invoke get method");
        return "lambda";
    };
    /**
     * 当大括号{}只有一行执行语句，则{}可以省略，如下写法都正确
     */
    Supplier<String> s2 = () -> {
        return "lambda";
    };
    Supplier<String> s3 = () -> "lambda";
    /**
     * 也可以返回null
     */
    Supplier<String> s4 = () -> null;

    System.out.println(s1.get());
    System.out.println(s2.get());
    System.out.println(s3.get());
    System.out.println(s4.get());
}

有一个参数，无返回值

/**
 * 测试只有一个参数，无返回值
 */
@Test
public void testArgsNoReturnValue(){
    /**
     *指定参数str 类型为String
     */
    Consumer<String> c0 = (String str)->{System.out.println("c0:"+str);};
    /**
     * 也可以不指定参数类型，会根据Consumer<String> 泛型自动推断接收的参数类型。
     * 当只有一个参数时，参数部分的小括号可以省略，如下c1/c2写法都正确
     */
    Consumer<String> c1 = (str)->{System.out.println("c1:"+str);};
    Consumer<String> c2 = str->{System.out.println("c2:"+str);};
    c0.accept("lambda");
    c1.accept("lambda");
    c2.accept("lambda");
}

有一个参数，有返回值

/**
 * 测试只有一个参数，有返回值场景
 */
@Test
public void testArgsReturnValue() {
    /**
     * Function<Integer, String>用于接收一个参数，输出一个返回值
     * 其中Integer表示输入参数类型，String表示返回值类型
     */
    Function<Integer, String> f1 = (Integer str) -> {
        return "f1:"+String.valueOf(str);
    };
    /**
     * 可以省略参数类型，省略大括号{}和return
     */
    Function<Integer, String> f2 = (str) -> {
        return "f2:"+String.valueOf(str);
    };
    Function<Integer, String> f3 = (str) -> "f3:"+String.valueOf(str);

    /**
     * 由于只有一个参数，也可以省略小括号()
     */
    Function<Integer, String> f4 = str -> "f4:"+String.valueOf(str);

    System.out.println(f1.apply(123));
    System.out.println(f2.apply(124));
    System.out.println(f3.apply(125));
    System.out.println(f4.apply(126));
}

多个参数，无返回值

/**
     * 测试多个参数，无返回值场景
     */
    @Test
    public void testMultiArgsNoReturn(){
        /**
         * BiConsumer<String,Integer> 用于接收2个不同类型的参数，泛型指定了两个参数的类型
         * 由于参数多余1个，则小括号()不能省略
         */
        BiConsumer<String,Integer> b1 = (String str, Integer num)->{System.out.println("b1:"+str+num);};
        /**
         * 参数类型可以省略，要么全部省略参数类型，如(str, num)是可以的，
         * 但是不能只省略一个类型则不可以，如(String str, num)或(str, Integer num)
         */
        BiConsumer<String,Integer> b2 = (str,  num)->{System.out.println("b2:"+str+num);};
//        BiConsumer<String,String> b3 = (str,  num)->{System.out.println("b3:"+str+num);};
        b1.accept("lambda",666);
        b2.accept("lambda",666);

    }

多个参数，有返回值

/**
 * 测试多个参数，有返回值场景
 */
@Test
public void testMultiArgsReturnValue(){
    /**
     * BiFunction<String,String,Integer> 用于接收2个输入参数，输出一个返回值，输入和输出是不同类型
     */
    BiFunction<String,String,Integer> f1 = (String str1,String str2)->{return str1.length()+str2.length();};
    /**
     * BinaryOperator<Integer> 用于接收2个输入参数，输出一个返回值，输入和输出是相同类型,是BiFunction的特殊情况
     */
    BinaryOperator<Integer> f11 = (Integer num1,Integer num2)->{return num1+num2;};
    /**
     * 省略参数类型
     */
    BiFunction<String,String,Integer> f2 = (str1, str2)->{return str1.length()+str2.length();};
    BinaryOperator<Integer> f22 = (num1, num2)->{return num1+num2;};
    /**
     * 省略大括号{}和return ,必须同时省略
     */
    BiFunction<String,String,Integer> f3 = (str1,str2)->str1.length()+str2.length();
    BinaryOperator<Integer> f33 = (num1, num2)->num1+num2;
    System.out.println(f1.apply("java"," lambda"));
    System.out.println(f2.apply("java"," lambda"));
    System.out.println(f3.apply("java"," lambda"));

    System.out.println(f11.apply(11,22));
    System.out.println(f22.apply(11,22));
    System.out.println(f33.apply(11,22));
}

由于本人水平有限，如有错误，欢迎拍砖