函数式接口(Functional interface)
就是一个且仅有一个抽象方法,但是可以有多个非抽象方法的接口。
函数式接口可以被隐式转换为lambda表达式。
如果定义一个函数式接口如下:
interface GreetingService
{
void sayMessage(String message);
}
那么就可以使用Lambda表达式来标识该接口的一个实现,(Java8之前一般用匿名类实现),Lambda表达式免去了使用内部匿名类的麻烦,给予Java简单强大的函数化编程能力。
GreetingService greetService1 = message -> System.out.println("Hello " + message);
lambda表达式语法:
(parameters) -> expression
(parameters) ->{ statements; }
注意:
1无需指定lambda表达式的返回类型。lambda表达式的返回类型总是会由上下文推导得出。
2 如果一个lambda表达式只在某些分支返回一个值,而在另一些分支不返回值,这是不合法的。
例如:
(int x)->{if(x>0) return 1;}//不合法
一些可以简化的写法:
可选的类型声明
(a, b) -> a - b;//不需要声明参数类型,编译器可以统一识别参数值
可选的参数圆括号
x -> 2 * x;//一个参数无需定义圆括号,但多个参数需要定义圆括号
可选的大括号
(String s) -> System.out.print(s);//如果主体包含了一个语句,就不需要使用大括号
可选的返回关键字
(int a, int b) -> { return a * b; };//如果主体只有一个表达式,编译器则自动回返回,大括号需要制定表明表达式返回了一个数值。
函数式接口+Lambda表达式:
public class Java8Tester {
public static void main(String args[]){
Java8Tester tester = new Java8Tester();
// 类型声明
MathOperation addition = (int a, int b) -> a + b;
// 不用类型声明
MathOperation subtraction = (a, b) -> a - b;
// 大括号中的返回语句
MathOperation multiplication = (int a, int b) -> { return a * b; };
// 没有大括号及返回语句
MathOperation division = (int a, int b) -> a / b;
System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
System.out.println("10 / 5 = " + tester.operate(10, 5, division));
// 不用括号
GreetingService greetService1 = message ->
System.out.println("Hello " + message);
// 用括号
GreetingService greetService2 = (message) ->
System.out.println("Hello " + message);
greetService1.sayMessage("Runoob");
greetService2.sayMessage("Google");
}
interface MathOperation {
int operation(int a, int b);
}
interface GreetingService {
void sayMessage(String message);
}
private int operate(int a, int b, MathOperation mathOperation){
return mathOperation.operation(a, b);
}
}
//代码转载 LovelyBear2019的博客
变量作用域:
Lambda表达式只能引用标记了final的外层局部变量,不能再lambda内部修改定义在域外的局部变量,否则会编译错误。
public class Java8Tester {
final static String salutation = "Hello! ";
public static void main(String args[]){
GreetingService greetService1 = message ->
System.out.println(salutation + message);
greetService1.sayMessage("Runoob");
}
interface GreetingService {
void sayMessage(String message);
}
}
也可以直接在lambda表达式中访问外层的局部变量:
public class Java8Tester {
public static void main(String args[]) {
final int num = 1;
Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
s.convert(2); // 输出结果为 3
}
public interface Converter<T1, T2> {
void convert(int i);
}
}
lambda表达式访问的局部变量可以不用声明为final,但是必须不可被后面的代码修改。
int num = 1;
Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
s.convert(2);
num = 5;
//报错信息:Local variable num defined in an enclosing scope must be final or effectively
final
Lambda表达式当中不允许声明一个与局部变量同名的参数or局部变量
String first = "";
Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length()); //编译会出错
方法引用
可能已经有现成方法可以完成你想要传递到其他代码的某个动作。
System.out::println //是一个方法引用(method reference) 它等价于lambda表达式
x->System.out.println(x);
Arrays.sort(strings,String::compareToIgnoreCase)
使用::操作符 分割 方法名 与对象or类名
object:: instanceMethod
Class::staticMethod
Class::instanceMethod
前两种情况汇总,方法引用等价于提供方法参数的lambda表达式, 对于第三种情况,第一个参数会成为目标
String:: compareToIgnoreCase 等用于(x,y)->x.compareToIgnoreCase(y);
类似于lambda表达式,方法引用不能独立存在,总是会转换为函数式接口的实例。
可以在方法引用中使用this参数。this::equals等同于x->this.equals(x),使用super也是合法的。
构造器引用
构造器引用于方法引用类似,只不过方法名为new
Person::new 是person构造器的一个引用。
将一个字符串列表,可以把它转换为一个Person对象数组。具体使用哪一个构造器呢,取决于上下文
ArrayList<String> names=.....;
Stream<Person> stream=name.stream().map(Person::new);
List<person> people=stream.collect(Collectors..toList());
如果有多个Person构造器,编译器会选择有一个String参数的构造器,因为它从上下文推导出这是在对一个字符串调用构造器。
可以用数组类型建立构造器引用,例如 int[]::new 是一个构造器引用,它有一个参数:即数组的长度。等价于 lambda表达式x->new int[x];
但是有一个限制,无法构造泛型类型T的数组。数组构造器引用对于客服这个限制很用。表达式 new T[n] 会产生错误,因为这会改为new Object[n]。对于
Person[] people=stream.toArray(Person[]::new);
处理Lambda表达式:
编写方法处理lambda表达式:
使用lambda表达式的重点是延迟执行(deferred execution)。毕竟,如果想要立即执行代码,完全可以直接执行,则无需把它包装在一个lambda表达式中。之所以希望以后执行:
public static void repeat(int n, Runnable action){
........
}
要接受这个lambda表达式,需要选择(偶尔可能需要提供)一个函数式接口。这里使用Runnable接口。
常用Lambda接口:
基本类型的函数式接口:
Java核心技术实战 再谈Comparator没有看懂,后续再看再总结吧