函数式接口

2021年7月6日 28点热度 0条评论 来源: 北涯

目录

1、函数式接口概述

有且仅有一个抽象方法的接口,通过在类上标注 @functionalInterface 注解进行检测。

该注解为可选,只要保证满足函数式接口定义的条件也照样是函数式接口,但是建议都加上该注解(规范)。

示例

@FunctionalInterface
public interface MyFunctionalInterface {
    void show();
}

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

示例

public class Test_01 {
    public static void main(String[] args) {
        // 匿名内部类方式
        startRunable(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 线程启动");
            }
        });

        // lambda方式
        startRunable(() -> System.out.println(Thread.currentThread().getName() + " 线程启动"));
    }
	
    // Runnable类是一个函数s接口
    public static void startRunable(Runnable r) {
        new Thread(r).start();
    }
}
Thread-0 线程启动
Thread-1 线程启动

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

示例: 按照字符串长度正序排序

public class Test_02 {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("bbb");
        list1.add("a");
        list1.add("cc");
        System.out.println("排序前 = " + list1);
        Collections.sort(list1);
        System.out.println("默认排序后 = " + list1);

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("bbb");
        list2.add("a");
        list2.add("cc");
        System.out.println("排序前 = " + list2);
        Collections.sort(list2, getComparator());
        System.out.println("自定义排序后 = " + list2);
    }

    // 按照字符串长度正序排序,将Comparator函数式接口作为返回值

    // lambda方式
    public static Comparator<String> getComparator() {
        return (s1, s2) -> s1.length() - s2.length();
    }

    // 方法引用方式
    public static Comparator<String> getComparator2() {
        return Comparator.comparingInt(String::length);
    }

    // 匿名内部类方式
    public static Comparator<String> getComparator3() {
        return new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        };
    }
}
排序前 = [bbb, a, cc]
默认排序后 = [a, bbb, cc]
排序前 = [bbb, a, cc]
自定义排序后 = [a, cc, bbb]

4、常用函数式接口

Java 8 在 java.util.function 包下预定义了大量的函数式接口供我们使用,以下为四大核心函数式接口

接口 说明
Supplier 生产型接口,接口中泛型指定什么类型,则 get 方法就生产该类型数据,T - 出参类型,没有入参
Consumer 消费型接口,消费的数据其类型由泛型指定,T - 入参类型,没有出参
Predicate 断言式接口,通常用于判断参数是否满足指定的条件,T - 入参类型,出参为 boolean 类型
Function<T,R> 函数式接口,通常用于对参数进行处理、转换(处理逻辑由 Lambda 表达式实现),然后返回一个新的值,T - 入参类型,R - 出参类型

4.1、Supplier 接口

方法 说明
T get() 该方法不需要参数,它会按照某种实现逻辑(由 Lambda 表达式实现)返回一个数据

示例

public class Test_03 {
    public static void main(String[] args) {
        String name = getString(() -> "勋悟空");
        System.out.println("name = " + name);

        Integer age = getInteger(() -> 500);
        System.out.println("age = " + age);
    }

    // 返回 String 类型数据
    public static String getString(Supplier<String> sup) {
        return sup.get();
    }

    // 返回 Integer 类型数据
    public static Integer getInteger(Supplier<Integer> sup) {
        return sup.get();
    }

    // 返回其它类型数据...
}
name = 勋悟空
age = 500

4.2、Consumer 接口

方法 说明
void accept(T t) 对给定的参数执行此操作
default Consumer andThen(Consumer after) 依次执行此操作,然后执行 after 操作

示例

public class Test_05 {
    public static void main(String[] args) {
        // 打印该字符串,消费了一次
        operatorString("勋悟空", System.out::println);
        
        // 先打印该字符串,再获取该字符串的长度,消费了两次
        operatorString("勋悟空", System.out::println, s -> System.out.println(s.length()));
    }

    // 方法1:消费一个字符串数据
    public static void operatorString(String name, Consumer<String> con) {
        con.accept(name);
    }

    // 方法2:对一个字符串数据连续消费两次
    public static void operatorString(String name, Consumer<String> con1, Consumer<String> con2) {
        // con1.accept(name);
        // con2.accept(name);

        // 写法优化
        con1.andThen(con2).accept(name);
    }
}
勋悟空
勋悟空
3

4.3、Predicate 接口

方法 说明
boolean test(T t) 对给定的参数进行判断(判断逻辑由 Lambda 表达式实现),返回一个布尔值
default Predicate negate() 返回一个逻辑的否定,对应 逻辑非( ! )
default Predicate and(Predicate other) 返回一个组合判断,对应 短路与(&&)
default Predicate or(Predicate other) 返回一个组合判断,对应 短路或(||)

示例

public class Test_07 {
    public static void main(String[] args) {
        // 方法1
        boolean b1 = checkString1("hello", s -> s.length() > 6); // false
        boolean b2 = checkString1("hello", s -> s.length() < 6); // true

        // 方法2
        boolean b3 = checkString2("hello", s -> s.length() > 6); // true
        boolean b4 = checkString2("hello", s -> s.length() < 6); // false

        // 方法3
        boolean b5 = checkString3("hello", s -> s.length() > 6, s -> s.length() < 6); // false
        boolean b6 = checkString3("hello", s -> s.length() > 3, s -> s.length() < 6); // true

        // 方法4
        boolean b7 = checkString4("hello", s -> s.length() > 6, s -> s.length() < 6); // true
        boolean b8 = checkString4("hello", s -> s.length() > 3, s -> s.length() < 6); // true
    }

    // 方法1:判断给定字符串是否满足要求
    public static boolean checkString1(String s, Predicate<String> pre) {
        return pre.test(s);
    }

    // 方法2:判断给定字符串是否满足要求(结果取反)
    public static boolean checkString2(String s, Predicate<String> pre) {
        return pre.negate().test(s);
    }

    // 方法3:对同一个字符串给出两个不同的判断条件,再把这两个结果做 短路与 运算,得出的结果做最终结果
    public static boolean checkString3(String s, Predicate<String> pre1, Predicate<String> pre2) {
        return pre1.and(pre2).test(s);
    }

    // 方法4:对同一个字符串给出两个不同的判断条件,再把这两个结果做 短路或 运算,得出的结果做最终结果
    public static boolean checkString4(String s, Predicate<String> pre1, Predicate<String> pre2) {
        return pre1.or(pre2).test(s);
    }
}
b1 = false
b2 = true
--------
b3 = true
b4 = false
--------
b5 = false
b6 = true
--------
b7 = true
b8 = true

4.4、Function 接口

方法 说明
R apply(T t) 将此函数应用于给定的参数
default Function andThen(Function after) 返回一个组合函数,首先将该函数应用于输入,然后将 after 函数应用于结果

示例

public class Test_09 {
    public static void main(String[] args) {
        // 方法1
        convert("1", Integer::parseInt);
        
        // 方法2
        convert(1, i -> String.valueOf(i + 10));
        
        // 方法3
        convert("1", Integer::valueOf, s -> String.valueOf(s + 100));
    }

    // 方法1:将一个字符串转换为Integer类型并在控制台输出
    public static void convert(String s, Function<String, Integer> fun) {
        Integer i = fun.apply(s);
        System.out.println("i = " + i);
    }

    // 方法2:将一个Integer类型数据加上一个整数之后,转换为字符串并在控制台输出
    public static void convert(int i, Function<Integer, String> fun) {
        String s = fun.apply(i);
        System.out.println("s = " + s);
    }

    // 方法3:将一个字符串转换为Integer类型,把Integer类型数据加上一个整数之后,再转为字符串并在控制台输出
    public static void convert(String s, Function<String, Integer> fun1, Function<Integer, String> fun2) {
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println("ss = " + ss);
    }
}
i = 1
s = 11
ss = 101
    原文作者:北涯
    原文地址: https://www.cnblogs.com/bybeiya/p/14974568.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系管理员进行删除。