本文共--字 阅读约--分钟 | 浏览: -- Last Updated: 2022-06-25
Lambda是一个匿名函数，我们可以把Lambda表达式理解为一段可以传递的代码，使用它可以写出更间接、更灵活的代码。
import org.junit.Test;
import java.util.Comparator;
public class LambdaTest {
@Test
public void test1() {
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("普通匿名子类写法重写的run方法");
}
};
r1.run();
Runnable r2 = () -> System.out.println("Lambda表达式实现的run方法");
r2.run();
}
@Test
public void test2() {
Comparator<Integer> com1 = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1, o2);
}
};
int compare1 = com1.compare(12, 21);
System.out.println(compare1);
System.out.println("====================");
// Lambda表达式
Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
int compare2 = com2.compare(12, 21);
System.out.println(compare2);
System.out.println("====================");
// 方法引用
Comparator<Integer> com3 = Integer::compare;
int compare3 = com3.compare(12, 21);
System.out.println(compare3);
}
}
// 总结
// Lambda表达式 (o1, o2) -> Integer.compare(o1, o2);
// -> ： lambda操作符或箭头操作符
// 左边： lambda形参列表 就是接口中抽象方法的形参列表
// 右边： lambda体，就是重写的抽象方法的方法体 可以用大括号包裹换行 写更多逻辑
// 使用：
// 1、无参无返回值 () -> System.out.println("Lambda表达式实现的run方法");
// 2、一个参数无返回值 (String s) -> { System.out.println(s); }
// 3、数据类型可以省略，编译器可以类型推断 (s) -> System.out.println(s);
// 4、参数只有一个，小括号可以省略 s -> System.out.println(s);
// 5、两个或以上参数，多条执行语句，并且可以由返回值。(o1, o2) -> { System.out.println(o1); ... ; return 1}
// 6、只有一条语句，return和大括号都可以省略 (o1, o2) -> o1.compareTo(o2);
Lambda表达式的本质：作为函数式接口的实例。
如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。我们可以在一个接口上使用@FunctionalInterface注解，检查它是否是一个函数式接口，之前用匿名实现类表示的现在都可以用Lambda表达式来写。
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
/**
* java内置的4大核心函数式接口
*
* 消费型接口 Consumer<T> void accept(T t)
* 供给型接口 Supplier<T> T get()
* 函数型接口 Function<T,R> R apply(T t)
* 断定型接口 Predicate<T> boolean test(T t)
*/
public class LambdaTest2 {
@Test
public void test1(){
// 旧的写法
happyTime(500, new Consumer<Double>() {
@Override
public void accept(Double aDouble) {
System.out.println(aDouble);
}
});
System.out.println("********************");
// Lambda表达式
happyTime(400,money -> System.out.println("Lambda表达式" + money));
}
public void happyTime(double money, Consumer<Double> con){
con.accept(money);
}
@Test
public void test2(){
List<String> list = Arrays.asList("北京","南京","天津","东京","西京","普京");
// 旧的写法
List<String> filterStrs = filterString(list, new Predicate<String>() {
@Override
public boolean test(String s) {
return s.contains("京");
}
});
// Lambda写法
List<String> filterStrs1 = filterString(list,s -> s.contains("京"));
}
//根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
public 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;
}
}
当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用。方法引用可以看做是Lambda表达式深层次的表达。要求实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的放方法的参数列表和返回值类型保持一致。
如下三种主要使用情况：
示例代码如下：
import org.junit.Test;
import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
public class MethodRefTest {
// 情况一：对象 :: 实例方法
//Consumer中的void accept(T t)
//PrintStream中的void println(T t)
@Test
public void test1() {
Consumer<String> con1 = str -> System.out.println(str);
con1.accept("北京");
System.out.println("*******************");
PrintStream ps = System.out;
Consumer<String> con2 = ps::println;
con2.accept("beijing");
}
//Supplier中的T get()
//Employee中的String getName()
@Test
public void test2() {
Employee emp = new Employee(1001,"Tom",23,5600);
Supplier<String> sup1 = () -> emp.getName();
System.out.println(sup1.get());
System.out.println("*******************");
Supplier<String> sup2 = emp::getName;
System.out.println(sup2.get());
}
// 情况二：类 :: 静态方法
//Comparator中的int compare(T t1,T t2)
//Integer中的int compare(T t1,T t2)
@Test
public void test3() {
Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
System.out.println(com1.compare(12,21));
System.out.println("*******************");
Comparator<Integer> com2 = Integer::compare;
System.out.println(com2.compare(12,3));
}
//Function中的R apply(T t)
//Math中的Long round(Double d)
@Test
public void test4() {
Function<Double,Long> func = new Function<Double, Long>() {
@Override
public Long apply(Double d) {
return Math.round(d);
}
};
System.out.println("*******************");
Function<Double,Long> func1 = d -> Math.round(d);
System.out.println(func1.apply(12.3));
System.out.println("*******************");
Function<Double,Long> func2 = Math::round;
System.out.println(func2.apply(12.6));
}
// 情况三：类 :: 实例方法 (有难度)
// Comparator中的int comapre(T t1,T t2)
// String中的int t1.compareTo(t2)
@Test
public void test5() {
Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
System.out.println(com1.compare("abc","abd"));
System.out.println("*******************");
Comparator<String> com2 = String :: compareTo;
System.out.println(com2.compare("abd","abm"));
}
//BiPredicate中的boolean test(T t1, T t2);
//String中的boolean t1.equals(t2)
@Test
public void test6() {
BiPredicate<String,String> pre1 = (s1, s2) -> s1.equals(s2);
System.out.println(pre1.test("abc","abc"));
System.out.println("*******************");
BiPredicate<String,String> pre2 = String :: equals;
System.out.println(pre2.test("abc","abd"));
}
// Function中的R apply(T t)
// Employee中的String getName();
@Test
public void test7() {
Employee employee = new Employee(1001, "Jerry", 23, 6000);
Function<Employee,String> func1 = e -> e.getName();
System.out.println(func1.apply(employee));
System.out.println("*******************");
Function<Employee,String> func2 = Employee::getName;
System.out.println(func2.apply(employee));
}
}
import org.junit.Test;
import java.util.Arrays;
import java.util.function.Function;
public class ConstructorRefTest {
//构造器引用
//Supplier中的T get()
//Employee的空参构造器：Employee()
@Test
public void test1(){
// 原始匿名子类的写法
Supplier<Employee> sup = new Supplier<Employee>() {
@Override
public Employee get() {
return new Employee();
}
};
System.out.println("*******************");
// Lambda表达式
Supplier<Employee> sup1 = () -> new Employee();
System.out.println(sup1.get());
System.out.println("*******************");
// 构造器引用
Supplier<Employee> sup2 = Employee :: new;
System.out.println(sup2.get());
}
//Function中的R apply(T t)
@Test
public void test2(){
Function<Integer,Employee> func1 = id -> new Employee(id);
Employee employee = func1.apply(1001);
System.out.println(employee);
System.out.println("*******************");
Function<Integer,Employee> func2 = Employee :: new;
Employee employee1 = func2.apply(1002);
System.out.println(employee1);
}
//BiFunction中的R apply(T t,U u)
@Test
public void test3(){
BiFunction<Integer,String,Employee> func1 = (id,name) -> new Employee(id,name);
System.out.println(func1.apply(1001,"Tom"));
System.out.println("*******************");
BiFunction<Integer,String,Employee> func2 = Employee :: new;
System.out.println(func2.apply(1002,"Tom"));
}
//数组引用
//Function中的R apply(T t)
@Test
public void test4(){
Function<Integer,String[]> func1 = length -> new String[length];
String[] arr1 = func1.apply(5);
System.out.println(Arrays.toString(arr1));
System.out.println("*******************");
Function<Integer,String[]> func2 = String[] :: new;
String[] arr2 = func2.apply(10);
System.out.println(Arrays.toString(arr2));
}
}
Stream API(java.util.stream)把真正的函数式编程风格引入到java中，使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用 Stream API来并行执行操作，简言之，Stream API提供了一种高效且易于使用的处理数据的方式。
Stream的操作三个步骤：
创建Stream：一个数据源（如：集合、数组），获取一个流。
中间操作：一个中间操作链，对数据源的数据进行处理。
终止操作（终端操作）：一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用。