函数式接口Consumer、BiConsumer、Supplier、Predicate、Function、BiFunction

BUG弄潮儿

发布于 2025-01-12 14:10:57

3390

文章被收录于专栏：JAVA乐园JAVA乐园

1.Consumer

Java Consumer接口来自Java 8中引入的 java.util.function包。Consumer是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递一个参数执行指定的方法)。

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

Consumer的功能方法是accept(T t)。

Consumer具有以下方法。

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

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class Test0807 {
    public static void main(String[] args) {
        
        Consumer<Integer> print = i -> System.out.print(i);
        //1
        print.accept(1);
        System.out.println("----------------->");


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

实例使用

public class Test0807 {

    public static void main(String[] args) {
        List<Integer> list = Stream.of(1, 2, 3, 4).collect(Collectors.toList());
        list.forEach(i-> System.out.println(i));
    }
}

2.BiConsumer

Java BiConsumer接口来自Java 8中引入的 java.util.function包。BiConsumer是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递两个参数执行指定的方法)。

BiConsumer的功能接口是一个接受两个参数并且不返回任何结果的操作。

BiConsumer的功能方法是accept(T t, U u)。

BiConsumer具有以下方法。

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

import com.google.common.collect.Maps;

import java.util.Map;
import java.util.function.BiConsumer;

public class Test0807 {

    public static void main(String[] args) {

        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 < 10; i++) {
            map.put(i+"",i);
        }

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

        //打印value乘以2
        BiConsumer<String,Integer> print2=(K,V)->{
            System.out.println("valueChange--->"+K+":"+V*2);
        };

        //打印key拼接a后打印value乘以2
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            print1.andThen(print2).accept(entry.getKey(), entry.getValue());
        }
    }
}

实际使用

import java.util.HashMap;
import java.util.Map;

public class Test0807 {

    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<>();
        map.put(1,"a");
        map.put(2,"b");
        map.put(3,"c");
        map.put(4,"d");
        map.forEach((k,v)->{
            System.out.println(k+":"+v);
        });
    }
}

3.Supplier

Java Supplier接口来自Java 8中引入的 java.util.function包。Supplier是一个功能接口，代表结果的提供者。

Supplier的功能接口是不需要接受参数并且获取结果的操作。

Supplier的功能方法是get()

示例

import com.google.common.collect.Lists;

import java.util.List;
import java.util.Random;
import java.util.function.Supplier;

public class Test0807 {

    public static void main(String[] args) {
        Supplier<Integer> supplier=()->new Random().nextInt(10)+1;
        List<Integer> list = Lists.newArrayList();
        for (int i = 0; i < 10; i++) {
            list.add(supplier.get());
        }
        list.forEach(i-> System.out.println(i));
    }
}

实际使用

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class Test0807 {

    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<>();
        map.put(1,"a");
        map.put(2,"b");
        map.put(3,"c");
        map.put(4,"d");
        ArrayList<Map.Entry<Integer, String>> collect = map.entrySet().stream().collect(Collectors.toCollection(() -> new ArrayList<>()));
        //等价于
        //ArrayList<Map.Entry<Integer, String>> collect = map.entrySet().stream().collect(Collectors.toCollection(ArrayList::new));
        System.out.println("collect = " + collect);
    }
}

4.Predicate

Java Predicate接口来自Java 8中引入的 java.util.function包。

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

方法名	作用作用
test(T t)	判断对象t是否满足条件，满足返回true，不满足返回false
and(Predicate<? super T> other)	判断对象t是否同时满足当前条件以及other条件，满足返回true，不满足返回false，相当于短路与&&
negate()	对test(T t)的结果取反
or(Predicate<? super T> other)	判断对象t是否满足当前条件或者满足other条件，满足返回true，不满足返回false，相当于短路或
isEqual(Object targetRef)	判断当前对象是否与对象targetRef属性值相等，相当于 Objects.equals(Object a, Object b)

示例：

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;
}

实际使用

import com.google.common.collect.Lists;

import java.util.List;

public class Test0807 {

    public static void main(String[] args) {
        List<Integer> list = Lists.newArrayList();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        //输出偶数
        list.stream().filter(i -> i % 2 == 0).forEach(i-> System.out.println(i));

    }
}

5.Function

Java Function接口来自Java 8中引入的 java.util.function包。

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

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

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

Function具有以下方法

方法名作用 R apply(T t); 对传入的参数t进行函数运算后返回R compose(Function<? super V, ? extends T> before) 先对传入的参数进行before函数运算，然后在before函数运算基础上面再进行当前函数运算 andThen(Function<? super R, ? extends V> after) 先对传入的参数进行当前函数运算，然后在当前函数运算基础上面再进行after函数运算 identity() 输入什么就返回什么示例：

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);
    }
}

实际使用

import com.google.common.collect.Lists;

import java.util.List;

public class Test0807 {

    public static void main(String[] args) {
        List<Integer> list = Lists.newArrayList();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        list.stream().map(i -> i * 2).forEach(i-> System.out.println(i));
    }
}

6.BiFunction

Java BiFunction接口来自Java 8中引入的 java.util.function包。

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

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

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

BiFunction具有以下方法

apply: 这是BiFunction功能接口的功能方法。apply方法对给定的参数进行这一操作。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


    }
}

实际使用

import java.util.HashMap;
import java.util.Map;

public class Test0807 {

    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<>();
        map.put(1,"a");
        map.put(2,"b");
        map.put(3,"c");
        map.put(4,"d");
        //value大写
        map.keySet().forEach(i->{
            map.computeIfPresent(i, (K, V) -> V.toUpperCase());
        });
        map.forEach((K,V)-> System.out.println(K+":"+V));
    }
}

来源：openatomworkshop.csdn.net/674033213a01316874d6f9fa.html

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2025-01-12，如有侵权请联系 cloudcommunity@tencent.com 删除

对象

本文分享自 BUG弄潮儿微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度