java中的函数式接口：（Consumer、BiConsumer、Supplier、Predicate、Function、BiFunction）

1. Consumer

说明：（1）consumer接口来自java8中引入的Java.util.function包

　　　（2）Consumer是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递一个参数执行指定的方法)。

功能：Consumer的功能接口是一个接受单一参数并且不返回任何结果的操作。必要时，"结果"可以存在在集合里面，Consumer的功能方法是accept(T t)

1. accept : 这是Consumer功能接口的功能方法。accept 方法对给定的参数进行这一操作。
2. andThen : 此方法返回一个组合的Consumer，该Consumer先执行原始的Consumer操作，然后按照从左到右的顺序执行给定的andThen操作

代码示例：

/*
注意consumer接收一个参数，正常不返回数值
/*
//直接返回String的长度
Consumer<String> print = data -> System.out.println(data.length());
print.accept("abcdefg");
System.out.println("-----------------");

List<Integer> list = Arrays.asList(1, 2, 3, 4);
//集合的每个元素乘以5
Consumer<List<Integer>> multiflyFive=i->{
    for (int j = 0; j < i.size(); j++) {
        i.set(j,i.get(j)*5);
    }
};
//打印每个元素
Consumer<List<Integer>> printList=i->{
    for (int j = 0; j < i.size(); j++) {
        System.out.print(i.get(j)+" ");
    }
};
//每个先乘以5之后再打印
//5 10 15 20
multiflyFive.andThen(printList).accept(list);

返回结果：

7
-----------------
5 10 15 20

　　2.BiConsumer

说明：（1）consumer接口来自java8中引入的Java.util.function包

　　　（2）BiConsumer是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递两个参数执行指定的方法)。

功能：BiConsumer的功能接口是一个接受两个参数并且不返回任何结果的操作。BiConsumer的功能方法是accept(T t, U u)。

1. accept : 这是Consumer功能接口的功能方法。accept 方法对给定的参数进行这一操作。
2. andThen : 此方法返回一个组合的BiConsumer，该BiConsumer先执行原始的BiConsumer操作，然后按照从左到右的顺序执行给定的andThen操作

代码示例：

//拼接map中的key和value，以：间隔
BiConsumer<String,Integer> print = (K, V) -> System.out.println(K+":"+V);
print.accept("1",2);
System.out.println("-----------------");

Map<String,Integer> map = Maps.newLinkedHashMap();
for (int i = 0; i < 3; i++) {
    map.put(i+"",i);
}

//打印key拼接a
BiConsumer<String,Integer> print1=(K,V)->{
    System.out.println("原始数据--->"+K+":"+V);
};

//打印value乘以2
BiConsumer<String,Integer> print2=(K,V)->{
    System.out.println("数值翻倍--->"+K+":"+V*2);
};
//打印key拼接a后打印value乘以2
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    print1.andThen(print2).accept(entry.getKey(), entry.getValue());
}

　返回结果：

1:2
-----------------
原始数据--->0:0
数值翻倍--->0:0
原始数据--->1:1
数值翻倍--->1:2
原始数据--->2:2
数值翻倍--->2:4

　　3.Supplier

说明：（1）Java Supplier接口来自Java 8中引入的 java.util.function包。

　　　（2）Supplier是一个功能接口，代表结果的提供者。

功能：Supplier的功能接口是不需要接受参数并且获取结果的操作。Supplier的功能方法是get()

代码示例：

//输出四个十以内的随机数
Supplier<Integer> supplier=()->new Random().nextInt(10);
List<Integer> list = Lists.newArrayList();
for (int i = 0; i < 4; i++) {list.add(supplier.get());
}
list.forEach(i-> System.out.println(i));

返回结果：

7
2
4
5

 

　4. Predicate

说明：（1）Predicate接口来自Java 8中引入的 java.util.function包。

　　　（2）Predicate是一个返回值布尔值的函数。

 

代码示例：

import lombok.Data;
import lombok.experimental.Accessors;
import org.apache.commons.lang3.StringUtils;

import java.util.function.Predicate;

public class Test0807 {

    public static void main(String[] args) {
        Stu stu1 = new Stu().setAge(20).setName("张三").setSex("男");

        //年龄是否大于20
        Predicate<Stu> condition1=i->i.getAge()>20;
        //是否性别是女
        Predicate<Stu> condition2=i-> StringUtils.equals("女",i.getSex());

        //判断stu1的年龄是否大于20
        boolean test1 = condition1.test(stu1);
        System.out.println("test1 = " + test1);//false

        //negate对结果取反
        boolean test11 = condition1.negate().test(stu1);
        System.out.println("test11 = " + test11);//false

        //判断stu1是否性别是女
        boolean test2 = condition2.test(stu1);
        System.out.println("test2 = " + test2);//false

        //判断stu1是否同时年龄大于20与性别是女
        stu1.setAge(25);
        boolean test3 = condition1.and(condition2).test(stu1);
        System.out.println("test3 = " + test3);//false

        //判断stu1是否年龄大于20或者性别是女
        boolean test4 = condition1.or(condition2).test(stu1);
        System.out.println("test4 = " + test4);//true

        //判断stu与stu1是否equals
        Stu stu = new Stu().setSex("男").setAge(25).setName("张三");
        boolean test5 = Predicate.isEqual(stu).test(stu1);
        System.out.println("test5 = " + test5);//true
    }
}

@Data
@Accessors(chain = true)
class Stu{

    private String name;

    private Integer age;

    private String sex;
}

　5. Function

说明：（1）Function接口来自Java 8中引入的 java.util.function包。

　　　（2）Function是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递一个参数执行指定的方法)。

功能：Function的功能接口是一个接受单一参数并且返回单一结果的操作。

　　　Function的功能方法是R apply(T t);

Function具有以下方法：

代码示例：

public class Test0807 {

    public static void main(String[] args) {

        Function<Integer,Integer> multi=i-> i*10;
        Integer result = multi.apply(10);
        System.out.println("result = " + result);

        Function<Integer,Integer> add=i -> i + 10;
        //先加10再乘以10
        result= multi.compose(add).apply(10);//(10+10)*10
        System.out.println("result = " + result);
        //先乘以10再加10
        result= multi.andThen(add).apply(10);//10*20+10
        System.out.println("result = " + result);
    }
}

 

 

　5. BiFunction

说明：（1）BiFunction接口来自Java 8中引入的 java.util.function包。

　　　（2）BiFunction是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递两个个参数执行指定的方法)。

功能：BiFunction的功能接口是一个接受两个参数并且返回单一结果的操作。

　　　BiFunction的功能方法是R apply(T t, U u);

BiFunction具有以下方法：

1. apply: 这是BiFunction功能接口的功能方法。apply方法对给定的参数进行这一操作。
2. andThen : 此方法返回一个组合的BiFunction，该BiFunction先执行原始的BiFunctionr操作，然后按照从左到右的顺序执行给定的andThen操作

代码示例：

import java.util.function.BiFunction;

public class Test0807 {

    public static void main(String[] args) {
        //value*10
        BiFunction<String,Integer,Integer> biFunction1=(K,V)->{
            V=V*10;
            return V;
        };
        Integer a = biFunction1.apply("a", 10);
        System.out.println("a = " + a);//10

        //value+10
        Integer a1 = biFunction1.andThen(i -> i + 10).apply("a", 10);//10*10+10
        System.out.println("a1 = " + a1);


        //key大写
        BiFunction<String,Integer,String> biFunction2=(K,V)->{
            K=K.toUpperCase();
            return K;
        };
        String a2 = biFunction2.apply("a", 10);
        System.out.println("a2 = " + a2);//A

        //拼接本身
        String a3 = biFunction2.andThen(i -> i.concat(i)).apply("a", 10);
        System.out.println("a3 = " + a3);//AA


    }
}

 

 

参考引用：https://blog.csdn.net/m0_46360888/article/details/132161245