从“追求尽量不出错”，到正视“出错|
收藏闪存小组博问

如此而已~~~

园龄：3年3个月粉丝：0关注：12

28_Java中的函数式接口

Java中的函数式接口

​ 可作为一个局部变量，或者参数传递

一、函数式接口概述

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

Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口

只有确保接口中有且只有一个抽象方法，Java中的Lambda才能够顺利进行推导

如何表示一个接口是函数式接口？

@FunctionalInterface	//使用这个注解放在接口定义的上方，这样可以检验接口是否为函数式接口

注意：

​ 我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算不写这个注解，只要满足接口中只有一个抽象方法就仍是函数是接口，但是推荐添加注释

参考代码：

package com.itheima_01;
@FunctionalInterface
public interface MyInterface {
    void show();
 
 
    //接口中的：默认、静态、私有方法都是实现体，不是“抽象方法”
    default void show3(){
 
    }
 
    static void show4(){
 
    }
 
    private static void show5(){
 
    }
}
package com.itheima_01;
/*
    函数式接口：有且仅有一个抽象方法的接口
 */
public class MyInterfaceDemo {
    public static void main(String[] args){
        MyInterface my = () -> System.out.println("函数式接口");
        my.show();
    }
}

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

需求：

​ 定义一个类（RunnableDemo），在类中提供两个方法

​ 一个方法是：startThread(Runnable r) 方法参数Runnable是一个函数式接口

​ 一个方法是主方法，在主方法中调用startThread方法

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

参考代码：

package com.itheima_02;
/*
    定义一个类（RunnableDemo），在类中提供两个方法
		一个方法是：startThread(Runnable r)	方法参数Runnable是一个函数式接口
		一个方法是主方法，在主方法中调用startThread方法
 */
public class RunnableDemo {
    public static void main(String[] args){
        //在主方法中调用startThread方法
 
        //使用匿名内部类的方式
        /*startThread(new Runnable() {
            @Override
            public void run() {
                //currentThread() 静态方法，获取当前线程对象
                System.out.println(Thread.currentThread().getName() + "线程启动了");
            }
        });*/
 
        //使用Lambda表达式
        startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));
    }
 
    private static void startThread(Runnable r){
        /*Thread t = new Thread(r);
        t.start();*/
        new Thread(r).start();
    }
}

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

需求：

​ 定义一个类（ComparatorDemo），在类中提供两个方法

​ 一个方法是：Comparator getComparator() 方法返回值Comparator是一个函数式接口

​ 一个方法是主方法，在方法中调用getComparator方法

如果方法的返回值是一个函数式接口，我们可以使用Lambda表达式作为结果返回

参考代码：

package com.itheima_02;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
 
/*
定义一个类（ComparatorDemo），在类中提供两个方法
		一个方法是：Comparator<String> getComparator() 方法返回值Comparator是一个函数式接口
		一个方法是主方法，在方法中调用getComparator方法
 
 */
public class ComparatorDemo {
    public static void main(String[] args){
        //构造使用的场景
 
        //定义一个集合存储字符串元素
        ArrayList<String> array = new ArrayList<String>();
 
        array.add("cccc");
        array.add("aa");
        array.add("b");
        array.add("ddd");
 
        System.out.println("排序前：" + array);
 
//        Collections.sort(array);    //只传递集合参数时，自然排序
        Collections.sort(array, getComparator());   //根据字符串长度进行排序
 
        System.out.println("排序后：" + array);
    }
 
    //返回一个比较器排序接口
    private static Comparator<String> getComparator(){
        //匿名内部类方式
        /*Comparator<String> comp = new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        };
 
        return comp;*/
 
       /* return new Comparator<String>(){
            @Override
            public int compare(String s1, String s2){
                return s1.length() - s2.length();
            }
        };*/
 
        //使用Lambda表达式
        return (String s1, String s2) -> {
            return s1.length() - s2.length();
        };
    }
}

四、常用的函数式接口

Java8在java.util.function包下预定了大量的函数式接口供我们使用

我们重点了解一下一下四个接口：

​ Supplier接口

​ Consumer接口

​ Predicate接口

​ Function接口

1、Supplier接口（生产数据）：

Supplier：包含一个无参的方法

​ T get()：获得结果

​ 该方法不需要参数，它会按照某种实现逻辑（由Lambda表达式实现）返回一个数据

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

参考代码：

package com.itheima_03;
 
import java.util.function.Supplier;
 
public class SupplierDemo {
    public static void main(String[] args){
//        String s = getString(() -> {
//            return "张三";
//        });
 
        String s = getString(() -> "张三");
 
        System.out.println(s);
 
        Integer i = getInteger(() -> 30);
        System.out.println(i);
    }
 
    //定义一个方法，返回一个整数数据
    private static Integer getInteger(Supplier<Integer> s){
        return s.get();
    }
 
    //定义一个方法，返回一个字符串数据
    private static String getString(Supplier<String> s){
        return s.get();
    }
}

练习：

​ 定义一个类（SupplierTest），在类中提供两个方法

​ 一个方法是：int getMax(Supplier sup) 用于返回一个int数组中的最大值

​ 一个方法是主方法，在主方法中调用getMax方法

参考代码：

package com.itheima_03;
 
import java.util.function.Supplier;
 
/*
    定义一个类（SupplierTest），在类中提供两个方法
		一个方法是：int getMax(Supplier<Integer> sup)	用于返回一个int数组中的最大值
		一个方法是主方法，在主方法中调用getMax方法
 */
public class SupplierTest {
    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();   //具体的实现动作由Lambda表达式来完成
    }
}
2、Consumer接口（处理数据）：

Consumer：包含两个方法

​ void accept(T t)：对给定的参数执行此操作

​ default Consumer andThen(Consumer after)：返回一个组合的Consumer，依次执行此操作，然后执行after操作

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

参考代码：

package com.itheima_04;
 
import java.util.function.Consumer;
 
/*
 Consumer<T>：包含两个方法
	void accept(T t)：对给定的参数执行此操作
	default Consumer<T> andThen(Consumer after)：返回一个组合的Consumer，依次执行此操作，然后执行after操作
	Consumer<T> 接口也被称为消费型接口（处理数据），它消费的数据的数据类型由泛型指定
 */
public class ConsumerDemo {
    public static void main(String[] args){
        //使用Lambda表达式
        /*operatorString("张三", (String s) -> {
            System.out.println(s);      //对这个传递的参数进行输出操作
        });*/
 
        operatorString("张三", (s) -> System.out.println(s));
 
        /*//使用方法引用
        operatorString("李四", System.out::println);*/
 
        operatorString("王五", (s) -> {
            //将通过StringBuilder将字符串反转后，再进行字符串转换输出
            System.out.println(new StringBuilder(s).reverse().toString());
        });
 
        System.out.println("----------------------");
 
        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);
 
        //使用接口中的默认方法
        //其实本质也是分别调用accept方法
        con1.andThen(con2).accept(name);
    }
 
    //定义一个方法，消费字符串数据
    private static void operatorString(String name, Consumer<String> con){
        con.accept(name);
    }
}

练习：

​ String[] strArray = {"张三,30", "李四,33","王五,34"};

​ 字符串数组中有多条信息，请按照格式："姓名：XX, 年龄：XX"的格式将信息打印出来

​ 要求：

​ 把打印姓名的动作作为第一个Consumer接口的Lambda实例

​ 把打印年龄的动作作为第二个Consumer接口的Lambda实例

​ 将两个Consumer接口按照顺序组合到一起使用

参考代码：

package com.itheima_04;
 
import java.util.function.Consumer;
 
/*
    String[] strArray = {"张三,30", "李四,33","王五,34"};
    字符串数组中有多条信息，请按照格式："姓名：XX, 年龄：XX"的格式将信息打印出来
	要求：
		把打印姓名的动作作为第一个Consumer接口的Lambda实例
		把打印年龄的动作作为第二个Consumer接口的Lambda实例
		将两个Consumer接口按照顺序组合到一起使用
 */
public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"张三,30", "李四,33","王五,34"};
 
        //使用Lambda表达式的方法传递
        /*printInfo(strArray, (String str) -> {
            String name = str.split(",")[0];    //split方法返回一个String[] 此处根据下标所以获取对应位置值
            System.out.print("姓名：" + name + ", ");
        }, (String str) -> {
            int age = Integer.parseInt(str.split(",")[1]);
            System.out.println("年龄：" + age);
        });*/
 
        printInfo(strArray, str -> System.out.print("姓名：" + str.split(",")[0] + ", "), str -> System.out.println(Integer.parseInt(str.split(",")[1])));
    }
 
    private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2){
        for(String str : strArray){
            con1.andThen(con2).accept(str);
        }
    }
}
3、Predicate接口（判断参数是否满足条件）：

Predicate：常用的四个方法

​ boolean test(T t)：对给定的参数进行判断（判断逻辑由Lambda表达式实现），返回一个布尔值

​ default Predicate negate()：返回一个逻辑的否定，对应逻辑非

​ default Predicate and(Predicate other)：返回一个组合判断，对应短路与

​ default Predicate or(Predicate other)：返回一个组合判断，对应短路或

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

参考代码（前两个方法）：

package com.itheima_05;
 
import java.util.function.Predicate;
 
/*
Predicate<T>：常用的四个方法中的两个
	boolean test(T t)：对给定的参数进行判断（判断逻辑由Lambda表达式实现），返回一个布尔值
	default Predicate<T> negate()：返回一个逻辑的否定，对应逻辑非
 */
public class PredicateDemo01 {
    public static void main(String[] args){
        /*boolean b1 = checkString("hello", (String s) -> {
            return s.length() > 8;  //这个字符串的长度是否大于八
        });*/
 
        //简化Lambda表达式参数
        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); //具体逻辑用Lambda表达式来实现
 
        //对结果进行一个逻辑非的运算
//        return !pre.test(s);
        return pre.negate().test(s);    //negate对这个对象进行逻辑非操作，并返回这个对象
    }
}

参考代码（后两个方法）：

package com.itheima_05;
 
import java.util.function.Predicate;
 
/*
后两个方法
    default Predicate<T> and(Predicate other)：返回一个组合判断，对应短路与
    default Predicate<T> or(Predicate other)：返回一个组合判断，对应短路或
 */
public class PredicateDemo02 {
    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){
        /*boolean b1 = pre1.test(s);
        boolean b2 = pre2.test(s);
        boolean b = b1 && b2;
        return b;*/
 
//        return pre1.and(pre2).test(s);
        return pre1.or(pre2).test(s);
    }
 
    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre){
        return pre.test(s);
    }
}

练习：

​ String[] strArray = {"张三,30","李四,34","王五,36","赵六,33","小老七,34"};

​ 字符串数组中有多条信息，请通过Predicate接口的拼装将符合条件的字符串筛选到集合ArrayList中，并遍历ArrayList集合

​ 同时满足如下要求：姓名长度大于2，年龄大于33

参考代码：

package com.itheima_05;
 
import java.util.ArrayList;
import java.util.function.Predicate;
 
/*
String[] strArray = {"张三,30","李四,34","王五,36","赵六,33","小老七,34"};
	字符串数组中有多条信息，请通过Predicate接口的拼装将符合条件的字符串筛选到集合ArrayList中，并遍历ArrayList集合
	同时满足如下要求：姓名长度大于2，年龄大于33
 */
 
public class PredicateTest {
    public static void main(String[] args){
        //定义一个字符串数组
        String[] strArray = {"张三,30","李四,34","王五,36","赵六,33","小老七,34"};
 
        ArrayList<String> array = null;
        array = myFilter(strArray, s -> s.split(",")[0].length() > 2,
                s -> Integer.parseInt(s.split(",")[1]) > 33);
 
        System.out.println("满足条件的数据：" + array);
    }
 
    //通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中
    private static ArrayList<String> myFilter(String[] str, Predicate<String> pre1, Predicate<String> pre2){
        //定义一个集合
        ArrayList<String> array = new ArrayList<String>();
 
        //遍历字符串数组
        for(String s : str){
            if(pre1.and(pre2).test(s)){
                array.add(s);
            }
        }
 
        return array;
    }
}
4、Function接口（将前一个泛型数据 转换 为后一个泛型数据）：

Function<T, R>：常用的两个方法

​ R apply(T t)：将此函数应用于给定的参数

​ default Function andThen(Function after)：返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果

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

参考代码：

package com.itheima_06;
 
import java.util.function.Function;
 
/*
Function<T, R>：常用的两个方法
	R apply(T t)：将此函数应用于给定的参数
	default<V> Function andThen(Function after)：返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
	Function<T,R>接口通常用于对参数进行处理，转换（处理逻辑用Lambda表达式实现），然后返回一个新的值
 */
public class FunctionDemo {
    public static void main(String[] args){
       /* convert("100", (String s) -> {
            return Integer.parseInt(s);
        });*/
 
        convert("100", s -> Integer.parseInt(s));   //Lambda表达式
//        convert("100", Integer::parseInt);  //方法引用，将Lambda参数传递给类中的静态方法
 
        System.out.println("----------");
 
        convert(100, i -> String.valueOf(i + 566));
 
        System.out.println("----------");
 
        convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 899));
 
 
    }
 
    //定义一个方法，把字符串转换为int类型，在控制台输出
    private static void convert(String s, Function<String, Integer> fun){
        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){
        /*Integer i = fun1.apply(s);
        String str = fun2.apply(i);*/
 
        String str = fun1.andThen(fun2).apply(s);
 
        System.out.println(str);
    }
}

练习：

​ String s = "林青霞,30";

​ 请按照我指定的要求进行操作：

​ 1、将字符串截取得到数字即年龄部分

​ 2、将上一步的年龄字符串转换成int类型的数据

​ 3、将上一步的int数据加70，得到一个int结果，在控制台输出

​ 请通过Function接口来实现函数拼接

参考代码：

package com.itheima_06;
 
import java.util.function.Function;
 
/*
    String s = "林青霞,30";
	请按照我指定的要求进行操作：
			1、将字符串截取得到数字即年龄部分
			2、将上一步的年龄字符串转换成int类型的数据
			3、将上一步的int数据加70，得到一个int结果，在控制台输出
	请通过Function接口来实现函数拼接
 */
public class FunctionTest {
    public static void main(String[] args){
        String s = "林青霞,30";
 
        /*convert(s, (String ss) -> {
            return s.split(",")[1]; //截取得到数字即年龄部分
        }, (String ss) -> {
            return Integer.parseInt(ss);    //年龄字符串转换成int类型的数据
        }, (Integer i) -> {
            return i + 70;  //数据加70，得到一个int结果
        });*/
 
        //简化后
        convert(s, ss -> s.split(",")[1], ss -> Integer.parseInt(ss), i -> i + 70);
    }
 
    private static void convert(String s, Function<String, String> fun1, Function<String, Integer> fun2, Function<Integer, Integer> fun3){
       int i = fun1.andThen(fun2).andThen(fun3).apply(s);
        System.out.println(i);
    }
}

本文作者：如此而已~~~

本文链接：https://www.cnblogs.com/fragmentary/p/17001800.html

版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   如此而已~~~  阅读(34)  评论(0)  编辑  收藏  举报
    //雪花飘落效果
    点击右上角即可分享
    微信分享提示
    AI IDE Trae
    评论
    收藏
    关注
    推荐
    深色
    回顶
    收起
    ✽
    ✽