16-Java 函数式接口笔记

函数式接口:有且仅有一个抽象方法的接口

Java中的函数式编程体现在Lambda表达式,所以函数式接口就是可以适用于Lambda使用的接口;只有确保接口中有且仅有一个抽象方法,Java中的Lambda才能顺利进行推导。
检测函数式接口:@FunctionalInterface

函数式接口作为方法的参数

如果方法的参数是一个函数式接口,我们可以使用Lambda表达式作为参数传递

startThread(()->sysout("线程启动了"));

函数式接口作为方法返回值

public static Comparator<String> getComparator() {
    
    
//        return new Comparator<String>() {
    
    
//            @Override
//            public int compare(String o1, String o2) {
    
    
//                return o1.length() - o2.length();
//            }
//        };
        return (s1, s2) -> s1.length() - s2.length();
    }

常用的函数式接口

Supplier

Supplier<T>:包含一个无参的方法

  • T get():获得结果
  • 该方法不需要参数,它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
  • 也称为生产型接口,如果我们指定了接口的泛型是什么类型,那么接口中的get方法就会生产什么类型的数据供我们使用
public static void main(String[] args) {
    
    

        int[] arr = {
    
    1, 3, 4, 6};

        int maxValue = getMaxInteger(() -> {
    
    
            int max = arr[0];
            for (int i = 0; i < arr.length; i++) {
    
    
                if (max < arr[i]) {
    
    
                    max = arr[i];
                }
            }
            return max;
        });

        System.out.println(maxValue);
    }
    
    public static Integer getMaxInteger(Supplier<Integer> sp) {
    
    
        return sp.get();
    }

Consumer接口

Consumer:包含两个方法

  • void accept(T t):对给定的参数执行此操作
  • default Consumer andThen(Consumer after):返回一个组合的Consumer,依次执行此操作,然后执行after操作
  • 也称为消费型接口, 它消费的数据类型有泛型指定

public class ConsumerDemo2 {
    
    
    public static void main(String[] args) {
    
    
        String[] arr = {
    
    "James,41", "Curry,31", "JeremyLin,32"};
        printInfo(arr, str -> System.out.print("Name: " + str.split(",")[0]),
                str -> System.out.println(", Age: " + str.split(",")[1]));
    }

    public static void printInfo(String[] arr, Consumer<String> c1, Consumer<String> c2) {
    
    
        for (String str : arr) {
    
    
            c1.andThen(c2).accept(str);
        }
    }
}

Predicate接口

Predicate:常用的四个方法

  • boolean test(T t):对给定的参数进行判断(判断逻辑由Lambda表达式实现),返回一个布尔值
  • default Predicate<T> negate():返回一个逻辑的否定,对应逻辑非
  • default Predicate<T> and(Predicate other):返回一个组合判断,对应短路与
  • default Predicate<T> or(Predicate other):返回一个组合判断,对应短路或
  • 此接口通常用于判断参数是否满足指定的条件
public class PredicateDemo1 {
    
    
    public static void main(String[] args) {
    
    

        boolean b1 = checkString("hello", s->s.length() > 8);
        System.out.println(b1);

        boolean b2 = checkString("Hello", s->s.length()>8, s -> s.length()<10);
        System.out.println(b2);
    }

    public static boolean checkString(String s, Predicate<String> p1, Predicate<String> p2) {
    
    
//        boolean b1 = p1.test(s);
//        boolean b2 = p2.test(s);
//        return b1 && b2;
//        return p1.and(p2).test(s);
        return p1.or(p2).test(s);
    }

    public static boolean checkString(String s, Predicate<String> pre) {
    
    
//        return pre.test(s);
//        return !pre.test(s);
        return pre.negate().test(s); // 逻辑非
    }
}

Function接口

表示接收一个参数,返回一个结果
Function<T, R>:常用的两个方法:

  • R apply(T t):将此函数应用于给定的参数
  • default <V> Function andThen(Function after):返回一个组合函数,首先将函数应用于输入,然后将after函数应用于结果

猜你喜欢

转载自blog.csdn.net/qq_42899028/article/details/119294508

相关文章