通过上面的 Lambda表达式的学习,我们认识了 新的语法,支持这种语法的接口
Lambda的表达式本质
其实就是函数式接口的实例
什么是函数式接口呢?
Runnable
接口就是一个很典型的函数式接口
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
这里我们自己定一个
@FunctionalInterface
public interface MyinterFace {
void method1();
}
函数式接口 | 参数类型 | 返回类型 | 用途 |
---|---|---|---|
Consumer 消费型接口 | T | void | 对类型为t的对象应用操作,包含方法void accept(T,t) |
Supperlier供给型接口 | 无 | T | 返回类型为T的对象,包含方法 T get() |
Function | T | R | 对类型为T的对象应用操作,并返回结果,结果是R类型的对象,包含方法 R apply(T t) |
Predicate | T | boolean | 确定类型为T的对象是否满足某个约束,并返回boolean值,包含方法 boolean test(T t) |
理论+实践
我们以 Consumer 与 Predicate举例子
/**
* @author : 冷环渊
* @date : 2021/12/11
* @context:
* 消费型接口 Consumer Accept(T t)
* 供给型接口 Supplier T get()
* 函数式接口 Function R apply(T t)
* 断定型接口 Predicate boolean test(T t)
*
*/
public class LambdaTest2 {
/**
* @author 冷环渊 Doomwatcher
* @context: Consumer 使用
* @date: 2021/12/11 14:37
* @param
* @return: void
*/
@Test
public void Test1() {
happyTime(500, new Consumer<Double>() {
@Override
public void accept(Double aDouble) {
System.out.println("天上人间的水今天很贵:" + aDouble);
}
});
System.out.println("****************************");
happyTime(400, money -> System.out.println("学习太累了,去天上人间买了瓶矿泉水,价格为:" + money));
}
/**
* @author: 冷环渊 Doomwatcher
* @context:
* @date: 2021/12/11 14:33
* @param money
* @param con
* @return void
*/
public void happyTime(double money, Consumer<Double> con) {
con.accept(money);
}
/**
* @author 冷环渊 Doomwatcher
* @context: 断言 Predicate 的使用
* @date: 2021/12/11 14:39
* @param
* @return: void
*/
@Test
public void Test2() {
//传统写法
List<String> filterList = Arrays.asList("北京", "天津", "南京", "东京", "江南");
List<String> filterStr = filterString(filterList, new Predicate<String>() {
@Override
public boolean test(String s) {
return s.contains("京");
}
});
System.out.println(filterStr);
System.out.println("*******************************");
// Lambda表达式 写法
List<String> filterList1 = Arrays.asList("北京", "天津", "南京", "东京", "江南");
List<String> filterStr1 = filterString(filterList1, s -> s.contains("京"));
System.out.println(filterStr1);
}
/**
* @author 冷环渊 Doomwatcher
* @context:
* @date: 2021/12/11 14:49
* @param list
* @param pre
* @return: java.util.List
*/
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;
}
}
方法引用
coding
准备两个类 一个是list集合,一个是对象
Employee
get/set 和 tostring 为防止无用篇幅过长,这里我们简写只看一下对象属性即可
package Lambda.MethodReferences;
/**
*
* @author : 冷环渊
* @date : 2021/12/11
* @context:提供用于测试的对象
*/
public class Employee {
private int id;
private String name;
private int age;
private double salary;
\
}
EmployeeData
package Lambda.MethodReferences;
import java.util.ArrayList;
import java.util.List;
/**
*
* @author : 冷环渊
* @date : 2021/12/11
* @context:提供用于测试的数据
*/
public class EmployeeData {
public static List<Employee> getEmployees() {
List<Employee> list = new ArrayList<>();
list.add(new Employee(1001, "马化腾", 34, 6000.38));
list.add(new Employee(1002, "马云", 12, 9876.12));
list.add(new Employee(1003, "刘强东", 33, 3000.82));
list.add(new Employee(1004, "雷军", 26, 7657.37));
list.add(new Employee(1005, "李彦宏", 65, 5555.32));
list.add(new Employee(1006, "比尔盖茨", 42, 9500.43));
list.add(new Employee(1007, "任正非", 26, 4333.32));
list.add(new Employee(1008, "扎克伯格", 35, 2500.32));
return list;
}
}
方法引用 test
/**
* @author : 冷环渊
* @date : 2021/12/11
* @context:
* 方法引用的使用
*
* 1.使用情境:当要传递给Lambda体的操作,已经有实现的方法了,可以使用方法引用!
* 2.方法引用,本质上就是Lambda表达式,而Lambda表达式作为函数式接口的实例。所以
* 方法引用,也是函数式接口的实例。
* 3. 使用格式: 类(或对象) :: 方法名
* 4. 具体分为如下的三种情况:
* 情况1 对象 :: 非静态方法
* 情况2 类 :: 静态方法
* 情况3 类 :: 非静态方法
* 5. 方法引用使用的要求:要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的
* 形参列表和返回值类型相同!(针对于情况1和情况2)
*
*
*
*/
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));
}
}
构造方法引用
通过 简化 的方式,来调用不同的构造器
一、构造器引用
二、数组引用
/**
*
* @author : 冷环渊
* @date : 2021/12/11
* @context:
*
* 一、构造器引用
* 和方法引用类似,函数式接口的抽象方法的形参列表和构造器的形参列表一致。
* 抽象方法的返回值类型即为构造器所属的类的类型
*
* 二、数组引用
* 大家可以把数组看做是一个特殊的类,则写法与构造器引用一致。
*
*/
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("*******************");
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));
}
}