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));
}
因为自己程度无限,如有谬误,欢送拍砖