Java成神路 —— 函数式接口

繁依Fanyi

发布于 2023-05-07 17:06:58

1690

发布于 2023-05-07 17:06:58

文章被收录于专栏：繁依Fanyi 的专栏

1.1 函数式接口概述

1. 概念

只包含一个抽象方法的接口称为函数式接口

2. 如何检测一个接口是不是函数式接口

@FunctionalInterface 放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败

3. 注意事项

我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解

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

示例代码：

public class Demo {
    public static void main(String[] args) {
        
        // 在主方法中调用 startThread方法
        
        // 匿名内部类的方式
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程启动了");
            }
        });
        
        // Lambda 方式
        startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));
    }
    
    private static void startThread(Runnable r) {
        new Thread(r).start();
    }
}

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

示例代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Demo {
    public static void main(String[] args) {

        //定义集合，存储字符串元素
        ArrayList<String> array1 = new ArrayList<String>();
        ArrayList<String> array2 = new ArrayList<String>();

        array1.add("cccc");
        array1.add("aa");
        array1.add("b");
        array1.add("ddd");
        
        // 复制 array1
        for(String s : array1){
            array2.add(s);
        }


        System.out.println("array1排序前：" + array1);
        System.out.println("array2排序前：" + array2);

        Collections.sort(array1, getComparator_1());
        Collections.sort(array2, getComparator_2());

        System.out.println("array1排序后：" + array1);
        System.out.println("array2排序后：" + array2);
    }

    // Lambda表达式的方式实现
    private static Comparator<String> getComparator_1() {
        return (s1, s2) -> s1.length() - s2.length();
    }

    // 匿名内部类的方式实现
    private static Comparator<String> getComparator_2() {
        return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        };
    }
}

1.2 Supplier 函数式接口

1. Supplier接口

Supplier接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的 get方法就会生产什么类型的数据供我们使用。

2. 常用方法

只有一个无参的方法

方法名	说明
T get()	按照某种实现逻辑(由Lambda表达式实现)返回一个数据

3. 代码演示

import java.util.function.Supplier;

public class Demo {
    public static void main(String[] args) {

        //定义一个int数组
        int[] arr = {19, 50, 28, 37, 46};

        int maxValue = getMax(()-> {
            int max = arr[0];

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

        System.out.println(maxValue);

    }

    //返回一个int数组中的最大值
    private static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}

1.3 Consumer 函数式接口

1. Consumer接口

Consumer接口也被称为消费型接口，它消费的数据的数据类型由泛型指定

2. 常用方法

Consumer：包含两个方法

方法名	说明
void accept(T t)	对给定的参数执行此操作
default Consumer andThen(Consumer after)	返回一个组合的Consumer，依次执行此操作，然后执行after操作

3. 代码演示

import java.util.function.Consumer;

public class Demo {
    public static void main(String[] args) {

        //操作一
        operatorString("小红", s -> System.out.println(s));

        //操作二
        operatorString("小红", s -> System.out.println(new StringBuilder(s).reverse().toString()));
        
        System.out.println("--------");

        //传入两个操作使用andThen完成
        operatorString("小红", s -> System.out.println(s), s -> 
                System.out.println(new StringBuilder(s).reverse().toString()));
    }
    
    //定义一个方法，用不同的方式消费同一个字符串数据两次
    private static void operatorString(String name, Consumer<String> con1,
                                       Consumer<String> con2) {

        // con1.accept(name);
        // con2.accept(name);
        con1.andThen(con2).accept(name);
   
    }
    
    //定义一个方法，消费一个字符串数据
    private static void operatorString(String name, Consumer<String> con) {
        con.accept(name);
    }
    
}

1.4 Predicate 函数式接口

1. Predicate接口

Predicate接口通常用于判断参数是否满足指定的条件

2. 常用方法

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

3. 代码演示

示例一：

import java.util.function.Predicate;

public class Demo {
    public static void main(String[] args) {
        boolean b1 = checkString("hello", s -> s.length() > 8);
        System.out.println(b1);
        boolean b2 = checkString("helloworld",s -> s.length() > 8);
        System.out.println(b2);
    }
    
    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre) {

        // return !pre.test(s);
        return pre.negate().test(s);
    }
}

示例二：

import java.util.function.Predicate;

public class Demo {
    public static void main(String[] args) {

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

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

        boolean b3 = checkString("hello",s -> s.length() > 8, s -> s.length() < 15);
        System.out.println(b3);
        
        boolean b4 = checkString("helloworld",s -> s.length() > 8, s -> s.length() < 15);
        System.out.println(b4);
        
    }
    
    //同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
    private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
        return pre1.or(pre2).test(s);
    }
    
    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre) {
        return pre.test(s);
    }
}

1.5 Function 函数式接口

1. Function接口

Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值

2. 常用方法

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

3. 代码演示

import java.util.function.Function;

public class Demo {
    public static void main(String[] args) {

        //操作一
        convert("100",s -> Integer.parseInt(s));

        //操作二
        convert(100,i -> String.valueOf(i + 566));

        //使用andThen的方式连续执行两个操作
        convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566));
    }
    
    //定义一个方法，把一个字符串转换int类型，在控制台输出
    private static void convert(String s, Function<String,Integer> fun) {

        // Integer i = fun.apply(s);
        int i = fun.apply(s);
        
        System.out.println(i);
    }
    
    //定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
    private static void convert(int i, Function<Integer,String> fun) {
        String s = fun.apply(i);
        System.out.println(s);
    }

    //定义一个方法，把一个字符串转换int类型，把int类型的数据加上一个整数之后，转为字符串在控制台输出
    private static void convert(String s, Function<String,Integer> fun1,
                                Function<Integer,String> fun2) {
       
        String ss = fun1.andThen(fun2).apply(s);
        
        System.out.println(ss);
        
    }
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2022-03-05，如有侵权请联系 cloudcommunity@tencent.com 删除

java