目录
前言
Lambda 表达式:在Java 8 语言中引入的一种新的语法元素和操作符。
函数式接口:只声明了一个抽象方法的接口。
方法引用:可以认为是Lambda表达式的一个语法糖。
一、为什么使用 Lambda 表达式?
Lambda 是一个匿名函数,我们可以把 Lambda 表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,使Java的语言表达能力得到了提升。
二、从匿名类 到 Lambda 的转换举例
1.Runnable接口的实现
代码如下(示例):
//匿名内部类
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("Hello World!");
}
};
//Lambda表达式
Runnable r2 = () -> System.out.println("Hello World!");
2.Comparator接口作为参数传递
代码如下(示例):
//原来使用匿名内部类作为参数传递
TreeSet<Integer> ts1 = new TreeSet<Integer>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1, o2);
}
});
//Lambda 表达式作为参数传递
TreeSet<Integer> ts2 = new TreeSet<Integer>(
(o1, o2) -> Integer.compare(o1, o2)
);
TreeSet 是 java.util 包下的。
三、Lambda 表达式:语法和使用方式
1.Lambda 表达式的基本语法
- Lambda 的操作符为 “->” ,该操作符被称为 Lambda 操作符 或 箭头操作符。它将 Lambda 分为两个部分。
- 左侧:指定了 Lambda 表达式需要的参数列表。
- 右侧:指定了 Lambda 体,是抽象方法的实现逻辑,也即 Lambda 表达式要执行的功能。
2.Lambda 表达式的使用:(分为6种情况介绍)
代码如下(示例):
//语法格式一:无参,无返回值
Runnable r2 = () -> System.out.println("Hello World!");
r2.run();
//语法格式二:Lambda 需要一个参数,但是没有返回值。
Consumer<String> con1 = (String s) -> System.out.println(s);
con1.accept("世上无难事,只怕有心人!");
//语法格式三:数据类型可以省略,因为可由编译器推断得出,称为“类型推断”
Consumer<String> con2 = (s) -> System.out.println(s);
con2.accept("世上无难事,只怕有心人!");
//语法格式四:Lambda 若只需要一个参数时,参数的小括号可以省略
Consumer<String> con3 = s -> System.out.println(s);
con3.accept("世上无难事,只怕有心人!");
//语法格式五:Lambda 需要两个或以上的参数,多条执行语句,并且可以有返回值
Comparator<Integer> com2 = (o1, o2) -> {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
System.out.println(com2.compare(12, 6));
//语法格式六:当 Lambda 体只有一条语句时,return 与大括号若有,都可以省略
Comparator<Integer> com3 = (o1, o2) -> o1.compareTo(o2);
System.out.println(com3.compare(12, 21));
类型推断:上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型,程序依然可以编译,这是因为 javac 根据程序的上下文,在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境,是由编译器推断出来的。这就是所谓的“类型推断”。
三、函数式(Functional)接口
1.什么是函数式(Functional)接口?
- 只包含一个抽象方法的接口,称为函数式接口。
- 你可以通过 Lambda 表达式来创建该接口的对象。(若 Lambda 表达式 抛出一个受检异常(即:非运行时异常),那么该异常需要在目标接口的抽象方法上进行声明)。
- 我们可以在一个接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明,说明这个接口是一个函数式接口。
- 在java.util.function包下定义了Java 8 的丰富的函数式接口。
2.如何理解函数式接口(与Lambda表达式的关系)
- Java从诞生日起就是一直倡导“一切皆对象”,在Java里面面向对象(OOP) 编程是一切。但是随着python、scala等语言的兴起和新技术的挑战,Java不得不做出调整以便支持更加广泛的技术要求,也即java不但可以支持OOP还可以支持OOF(面向函数编程).
- 在函数式编程语言当中,函数被当做一等公民对待。在将函数作为一等公民的编程语言中,Lambda表达式的类型是函数。但是在Java8中,有所不同。在Java8中,Lambda表达式是对象,而不是函数,它们必须依附于一类特别的对象类型——函数式接口。
- 简单的说,在Java8中,Lambda表达式就是一个函数式接口的实例。这就是 Lambda表达式和函数式接口的关系。也就是说,只要一个对象是函数式接口的实例,那么该对象就可以用Lambda表达式来表示。
- 所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。
3.函数式接口举例
这个是jdk中内置的Runnable接口,它就是典型的函数式接口。
4.java8 内置的4大核心函数式接口
代码如下(示例):
//消费型接口 Consumer<T> void accept(T t)
public static void consumer(double money, Consumer<Double> con) {
con.accept(money);
}
//供给型接口 Supplier<T> T get()
public static String supplier(Supplier<String> sup) {
return sup.get();
}
//函数型接口 Function<T,R> R apply(T t)
public static String function(Integer id, Function<Integer, String> fun) {
return fun.apply(id);
}
//断定型接口 Predicate<T> boolean test(T t)
//根据给定的规则,过滤集合中的字符串。此规则由Predicate的方法决定
public static List<String> filterString(List<String> list, Predicate<String> pre) {
ArrayList<String> filterList = new ArrayList<>();
for (String s : list) {
if (pre.test(s)) {
filterList.add(s);
}
}
return filterList;
}
public static void main(String[] args) {
consumer(400, money -> System.out.println("价格为:" + money));
System.out.println(supplier(() -> "你好!"));
System.out.println(function(1001, id -> "我的编号是:" + id));
System.out.println(filterString(Arrays.asList("北京", "南京", "天津"), s -> s.contains("京")));
}
- 上述的函数式接口都使用Lambda表达式实现。
- 作为参数传递 Lambda 表达式:为了将 Lambda 表达式作为参数传递,接收Lambda 表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型。
5.java8内置的其他函数式接口
java.util.function 包下有很多内置函数式接口,可自行探索
函数式接口 | 参数类型 | 返回类型 | 用途 |
---|---|---|---|
BiFunction<T,U,R> | T, U | R | 对类型为 T, U 参数应用操作,返回R类型的结果。包含方法为: R apply(T t, U u); |
UnaryOperator<T> (Function子接口) | T | T | 对类型为T的对象进行一元运算,并返回T类型的结果。包含方法为:T apply(T t); |
BinaryOperator<T> (Function子接口) | T,T | T | 对类型为T的对象进行二元运算,并返回T类型的 结果。包含方法为: T apply(T t1, T t2); |
BiConsumer<T,U> | T, U | void | 对类型为T, U 参数应用操作。 包含方法为: void accept(T t, U u) |
BiPredicate<T,U> | T,U | boolean | 包含方法为: boolean test(T t,U u) |
ToIntFunction<T> ToLongFunction<T> ToDoubleFunction<T> | T | int long double | 分别计算int、long、double值的函数 |
IntFunction<R> LongFunction<R> DoubleFunction<R> | int long double | R | 参数分别为int、long、double 类型的函数 |
6.自定义函数式接口
代码如下(示例):
//自定义函数式接口
@FunctionalInterface
public interface MyInterface1 {
void method1();
}
//函数式接口中使用泛型
@FunctionalInterface
public interface MyInterface2<T> {
T getValue(T t);
}
public static void main(String[] args) {
MyInterface1 func1 = () -> System.out.println("自定义函数式接口");
func1.method1();
MyInterface2<String> func2 = s -> "你好:"+s;
func2.getValue("小明");
}
- 如果一个接口中,只声明了一个抽象方法,则此接口就称为函数式接口。我们可以在一个接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数式接口。
- 以前用匿名实现类表示的现在都可以用Lambda表达式来写
四、方法引用
1.方法引用
- 当要传递给Lambda体的操作,已经有实现的方法了,可以使用方法引用!
- 方法引用可以看做是Lambda表达式深层次的表达。换句话说,方法引用就是Lambda表达式,也就是函数式接口的一个实例,通过方法的名字来指向一个方法,可以认为是Lambda表达式的一个语法糖。
- 要求:实现接口的抽象方法的参数列表和返回值类型,必须与方法引用的方法的参数列表和返回值类型保持一致!
- 格式:使用操作符 “::” 将类(或对象) 与 方法名分隔开来。
- 如下三种主要使用情况:对象::实例方法名 类::静态方法名 类::实例方法名
代码如下(示例):
// 情况一:对象 :: 实例方法
PrintStream ps = System.out;
Consumer<String> con2 = ps::println;
con2.accept("beijing");
// 情况二:类 :: 静态方法
Comparator<Integer> com2 = Integer::compare;
System.out.println(com2.compare(12, 3));
// 情况三:类 :: 实例方法 (有难度)
//注意:当函数式接口方法的第一个参数是需要引用方法的调用者,
//并且第二个参数是需要引用方法的参数(或无参数)时:ClassName::methodName
// String中的 int t1.compareTo(t2)
Comparator<String> com3 = String::compareTo;
System.out.println(com3.compare("abd", "abm"));
//BiPredicate中的boolean test(T t1, T t2);
//String中的boolean t1.equals(t2)
BiPredicate<String, String> pre2 = String::equals;
System.out.println(pre2.test("abc", "abd"));
方法引用,本质上就是Lambda表达式,而Lambda表达式作为函数式接口的实例。所以方法引用,也是函数式接口的实例。
2.构造器引用
- 格式: ClassName::new 与函数式接口相结合,自动与函数式接口中方法兼容。 可以把构造器引用赋值给定义的方法,要求构造器参数列表要与接口中抽象方法的参数列表一致!且方法的返回值即为构造器对应类的对象。
代码如下(示例):
public class Main02 {
class Employee {
Employee() {
}
}
public static void main(String[] args) {
Main02 main02 = new Main02();
main02.test1();
}
private void test1() {
Supplier<Employee> sup2 = Employee::new;
System.out.println(sup2.get());
}
}
3.数组引用
- 格式: type[] :: new
- 大家可以把数组看做是一个特殊的类,则写法与构造器引用一致.
代码如下(示例):
Function<Integer, String[]> func2 = String[]::new;
String[] arr2 = func2.apply(10);
System.out.println(Arrays.toString(arr2));
总结
以上就是Lambda表达式(函数式接口、方法引用)的全部内容了,本文仅仅简单介绍了基本使用,大家可以多多尝试使用Lambda表达式,体会它的简洁与强大。