常见的函数式接口
Consumer消费接口：在方法中传入参数进行消费 void accept(T t)
Function计算转换接口：可以在方法中对传入的参数进行计算或转换，把结果返回 R apply(T t)
Predicate判断接口：可以在方法中传入参数条件，返回判断结果boolean test(T t)
Supplier生产型接口：可以在方法中创建对象，把创建好的对象返回T get()
Consumer:传入一个参数，并对其进行相应的操作
public static void main(String[] args) {
List<String> list = new ArrayList();
list.add("qqq");
list.add("aaa");
// 1.直接创建接口
Consumer<String> consumer1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
// 直接使用consumer
list.stream().forEach(consumer1);
// 2.lambda表达式使用
Consumer<String> consumer2 = System.out::println;
list.stream().forEach(consumer2);
}
Supplier：可以传入数据，作为一个容器
Supplier可以简单的视为就是一个存放指定类型的容器，需要时再取出来:
public static void testSupplier(){
//1.直接创建
Supplier<String> supplier = new Supplier<String>() {
@Override
public String get() {
return "this is supplier";
}
};
System.out.println(supplier.get());
//2.lambda
Supplier<String> supplier1 = () -> "this is supplier";
System.out.println(supplier1.get());
}
Function: 主要是用作数据类型之间的转换
Function的抽象方法只有一个apply，即对传入的参数进行处理并返回，其他的都是辅助方法：
//1、apply 示例
private static void applyTest() {
//示例1：利用lambda方式实现一个funciton,将String转换为Integer
Function<String,User> function = new Function<String, User>() {
@Override
public User apply(String s) {
User user = new User();
user.setName(s);
return user;
}
};
User tom = function.apply("tom");
System.out.println(tom);
Function<String, Integer> function1 = x -> Integer.parseInt(x);
Integer a = function1.apply("100");
System.out.println(a.getClass());
}
compose:组合函数，调用当前function之前调用
andThen:组合函数，调用当前function之后调用
identity:静态方法，返回与原函数参数一致的结果。x=y
//2、andThen 示例——实现一个函数 y=10x + 10;
private static void andThenTest() {
//先执行 10 * x
Function<Integer, Integer> function2 = x -> 10 * x;
//通过andThen在执行 这里的x就等于上面的10 * x的值
function2 = function2.andThen(x -> x + 10);
System.out.println(function2.apply(2));
}
//3、compose 示例-实现一个函数 y=(10+x)2
private static void composeTest() {
Function<Integer, Integer> function3 = x -> x * 2;
//先执行 x+10 在执行(x+10)*2顺序与上面相反
function3 = function3.compose(x -> x + 10);
System.out.println(function3.apply(3));
}
//4、综合示例
//使用compose()、andThen()实现一个函数 y=(10+x)*2+10;
private static void test() {
//真正执行的第二步
Function<Integer, Integer> function4 = x -> x * 2;
//真正执行的第一步
function4 = function4.compose(x -> x + 10);
//真正执行的第三步
function4 = function4.andThen(x -> x + 10);
System.out.println(function4.apply(3));
}
Predicate：传入参数，而后返回判断的结果true/false
public static void testPredicate(){
//1.直接创建
Predicate<String> predicate = new Predicate<String>() {
@Override
public boolean test(String s) {
if ("test".equals(s)) {
return true;
}
return false;
}
};
System.out.println(predicate.test("test"));
// 2.lambda
Predicate<String> predicate1 = "test"::equals;
predicate1.test("test");
}
