关于redis:玩转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));
}

因为自己程度无限，如有谬误，欢送拍砖