java基础复习--常用的4个函数式接口

常用的4个函数式接口

前言

大家好，我是一名正在努力学java的学生，注册CSDN有段时间了，今天终于心血来潮想冒个泡！水平有限，望各位笑纳。

JDK8.0最大的热点，就是迎来函数式编程，在java.util.function包下，更新了众多函数式接口。
使用lambda表达式，极大地提升了敲代码的效率，但是对初学者来说可能比较难以理解，今天复习基础知识中顺便复习了函数式接口。

一：Supplier

方法：

T get()

public class TestSupplier {

    private static <T> T get(Supplier<T> sup){
        return sup.get();
    }
    private static <T> T get(Supplier<T> sup,T[] array){
        return sup.get();
    }
    
    //Supplier生产者
    @Test
    public void test(){
        String str = get(new Supplier<String>() {
            @Override
            public String get() {
                return "hello";
            }
        });
        System.out.println(str);

        //lambda优化
        //求任意数组最大值(只能接收引用类型的数组)
        Integer[] array = {3,2,4,5,1};
        Integer result = get(() -> {
            int max = array[0];
            for (int i : array) {
                if (i > max) {
                    max = i;
                }
            }
            return max;
        }, array);
        System.out.println(result);
    }
}

二：Consumer

方法：

void accept(T t)
default Consumer andThen(Consumer<? super T> after)

public class TestConsumer {

    //Consumer消费者
    private static <T> void accept(T t, Consumer<T> con){
        con.accept(t);
    }

    //default Consumer<T> andThen(Consumer<? super T> after)
    private static <T> void accept(T t,Consumer<T> con1 ,Consumer<T> con2){
        con1.andThen(con2).accept(t);//先执行con1再执行con2
    }

    private static <Map> void invoke(Map map,Supplier<Map> sup, Consumer<Map> con){
        con.accept(sup.get());
    }

    private static void invoke(Map<String,Integer> map) {
        invoke(map, () -> {
            Map<String,Integer> newMap = new HashMap<>();
            Set<String> keySet = map.keySet();
            for (String key : keySet) {
                Integer value = map.get(key);
                if (value >= 60) {//过滤掉成绩低于60分的人
                    newMap.put(key,value);
                }
            }
            map.clear();
            map.putAll(newMap);
            return map;
        }, stringIntegerMap -> {
            int avg = 0;
            Integer sum = 0;
            Set<String> keySet = map.keySet();
            for (String key : keySet) {
                Integer value = map.get(key);
                sum += value;
            }
            avg = sum / map.size();
            System.out.println(avg);
        });
    }

    @Test
    public void test(){
        //计算班上所有同学的平均成绩
        Map<String, Integer> map = Map.of("zhangsan", 100, "lisi", 80, "wangwu", 60);
        accept(map,(m -> {
            Set<String> keySet = map.keySet();
            int avg = 0;
            int sum = 0;
            for (String key : keySet) {
                Integer value = map.get(key);
                sum += value;
            }
            avg = sum / map.size();
            System.out.println(avg);
        }));
    }

    @Test
    public void test02(){
        //计算班上所有同学的平均成绩,再计算学生个数
        Map<String, Integer> map = Map.of("zhangsan", 100, "lisi", 80, "wangwu", 60);

        accept(map,(m1)->{
            Set<String> keySet = map.keySet();
            int avg = 0;
            int sum = 0;
            for (String key : keySet) {
                Integer value = map.get(key);
                sum += value;
            }
            avg = sum / map.size();
            System.out.println(avg);
        },(m2)-> System.out.println(map.size()));

    }

    @Test
    public void test03(){
        HashMap<String, Integer> map = new HashMap<>();
        map.put("jack",100);
        map.put("mike",80);
        map.put("tom",60);
        map.put("jerry",40);
        invoke(map);
    }
}

三：Predicate

方法：

boolean test(T t)
default Predicate and(Predicate<? super T> other)
default Predicate or(Predicate<? super T> other)
default Predicate negate()

public class TestPredicate {

    //Predicate
    //boolean test(T t)
    //default Predicate<T> and(Predicate<? super T> other) 与
    //default Predicate<T> or(Predicate<? super T> other) 或
    //default Predicate<T> negate() 非

    @Test
    public void test(){
        String str = "12345";
        boolean b = test(str,(s -> str.length() > 3));//true
        System.out.println(b);
    }

    private static <T> boolean test(T t, Predicate<T> p){
        return p.test(t);
    }
}

四：Function

方法：

R apply(T t)
default Function<T,V> void change()

public class TestFunction {

    //Function<T,R>接口

    //R apply(T t)
    //default <V> Function<T,V> andThen(Function<? super R,? extends V> after)

    @Test
    public void test(){
        StringBuffer sb = new StringBuffer();
        Object[] objects = {1,'a','B',3.14d,true,"我"};
        String str = change(sb, stringBuffer -> {
            sb.append(Arrays.toString(objects));
            return sb.toString();
        }, objects);
        System.out.println(str);
    }

    //封装成一个方法：将StringBuffer转变成String
    private static String change(StringBuffer sb, Function<StringBuffer,String> fun,Object[] objs){
        return fun.apply(sb);
    }
}

小结：

在测试Supplier接口和Consumer接口结合使用，调用Map集合的remove和replace方法时报错了。

原因据说是HashMap集合底层有一个count计数器。有知道具体原因的可以告诉我。谢谢！