常用的函数式接口FunctionInterface

最新推荐文章于 2024-05-13 09:21:07 发布
最新推荐文章于 2024-05-13 09:21:07 发布
阅读量558 收藏
点赞数
文章标签： java 字符串 函数式编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lu_qq/article/details/104805981
版权

常见的四类函数式接口

Supplier 生产者, 返回一个指定类型的数据

	有且只有一个方法
	T get();
	不需要参数，返回指定T类型数据

package com.qfedu.c_supplier;

import java.util.function.Supplier;

/**
 * 利用函数式接口Supplier其中get方法，找出数组中最大值下标位置
 *
 * @author Anonymous 2020/3/11 14:54
 */
public class Demo2 {
    public static void main(String[] args) {
        int[] array = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};

        /*
        getMax方法需要的参数是一个Supplier函数式接口，这里可以使用Lambda表达式完成
         */
        int max = getMax(() -> {
            int index = 0;

            for (int i = 1; i < array.length; i++) {
                if (array[index] < array[i]) {
                    index = i;
                }
            }

            return index;
        });

        System.out.println(max);
    }

    /**
     * 利用函数式接口完成一个getMax，提供一个操作思想
     *
     * @param sup Supplier函数式接口
     * @return 最大值下标位置
     */
    public static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}
package com.qfedu.c_supplier;

import java.util.function.Supplier;

/**
 * 演示Supplier函数式接口使用，对于方法的拓展能力和
 * 普适性满足
 *
 * @author Anonymous 2020/3/11 15:06
 */
public class Demo3 {
    public static void main(String[] args) {
        Integer[] array = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};

        Integer max = getMax(array, () -> {
            Integer temp = array[0];

            for (int i = 1; i < array.length; i++) {
                if (temp < array[i]) {
                    temp = array[i];
                }
            }

            return temp;
        });

        System.out.println(max);

        System.out.println("-------------------------------------------");

        Person[] persons = {new Person(1, "骚磊", 16),
                new Person(2, "老黑", 66),
                new Person(3, "老付", 36),
                new Person(4, "老高", 26),
                new Person(5, "污云", 96),
                new Person(6, "帅栋", 106)
        };

        Person max1 = getMax(persons, () -> {
            Person p = persons[0];

            for (int i = 1; i < persons.length; i++) {
                if (p.getAge() < persons[i].getAge()) {
                    p = persons[i];
                }
            }

            return p;
        });

        System.out.println(max1);
    }

    /**
     * 找出任意类型数组中最大数据
     *
     * @param arr 任意类型数组，同时约束当前泛型的使用规则
     * @param sup Supplier函数式接口，要利用get方法，返回指定T类型数据
     * @param <T> 泛型
     * @return 和数组类型一致的数据
     */
    public static <T> T getMax(T[] arr, Supplier<T> sup) {
        return sup.get();
    }
}

Consumer

操作使用的方式是
void accept(T t);
	根据接口指定的数据类型接收对应数据，进行处理和消费，对外没有任何的返回
	至于处理的过程，展示，处理，计算。。。

package com.qfedu.d_consumer;

import java.util.function.Consumer;

/**
 * 使用Consumer处理数据
 *
 * @author Anonymous 2020/3/11 15:24
 */
public class Demo1 {
    public static void main(String[] args) {
        // 该方法需要的参数是一个String类型，同时使用Consumer接口处理数据
        // 因为Consumer接口是一个函数式接口，可以使用Lambda表达式
        testConsumer("宫保鸡丁,番茄牛腩,酱牛肉,黄焖鸡米饭", (str) -> {
            String[] split = str.split(",");
            for (String s : split) {
                System.out.println(s);
            }
        });
    }

    /**
     * 给予当前方法一个String类型，通过Consumer函数式接口中的accept方法完成对应
     * 字符串处理
     *
     * @param str String类型字符串
     * @param consumer Consumer处理数据的函数式接口
     */
    public static void testConsumer(String str, Consumer<String> consumer) {
        consumer.accept(str);
    }
}

package com.qfedu.d_consumer;

import java.util.function.Consumer;

/**
 * Consumer接口andThen使用
 * 需要两个Consumer接口，两个Consumer接口进行组合处理，对数据进行消费
 *
 * andThen(Consumer<T> con)
 *      调用格式
 *          con1.andThen(con2).accept(T t);
 *          等价于一下操作
 *          con1.accept(t);
 *          con2.accept(t);
 *
 * @author Anonymous 2020/3/11 15:57
 */
public class Demo2 {
    public static void main(String[] args) {
        /*
        该方法需要两个Consumer函数式接口，这里可以使用两个Lambda表达式操作
         */
        testAndThen("郑州加油!!!中国加油!!!",
                (str) -> System.out.println(str)
                ,
                (str) -> System.err.println(str)
                );
    }

    /**
     * 使用两个Consumer消费者方式处理str数据，首先是con1处理，再来con2处理
     *
     * @param str  需要处理的String类型数据
     * @param con1 Consumer<String> 处理String类型函数式接口
     * @param con2 Consumer<String> 处理String类型函数式接口
     */
    public static void testAndThen(String str, Consumer<String> con1, Consumer<String> con2) {
        /*
        con1.accept(str);
        con2.accept(str);

        允许组合拳
        con1.andThen(con2).andThen(con1).andThen(con2).andThen(con1).andThen(con2).accept(str);
        */
        con1.andThen(con2).accept(str);
    }
}

Predicate一般用于调节判断，过滤数据的方法

函数式接口中指定的方法
boolean test(T t);
	处理T类型数据，返回boolean true / false

package com.qfedu.e_predicate;

import java.util.function.Predicate;

/**
 * 演示Predicate<T>基本使用
 *      boolean test(T t)
 *
 * @author Anonymous 2020/3/11 16:11
 */
public class Demo1 {
    public static void main(String[] args) {

        // Predicate函数式接口，使用Lambda表达式作为方法的参数
        boolean b = testPredicate("郑州奥力给!!!中国奥力给!!!",
                (str) -> {
                    return str.contains("加油");
                });

        System.out.println("ret : " + b);

        System.out.println("---------------------------");

        /*
        优化Lambda表达式，
            因为是一个参数，小括号可以省略
            就一行代码，大括号可以省略
            return也可以省略
         */
        testPredicate("郑州奥力给!!!中国奥力给!!!", str -> str.contains("加油"));
    }

    /**
     * 使用Predicate函数式接口利用boolean test(T t)对于当前数据进行判断操作，
     * 返回boolean类型数据
     *
     * @param str 需要进行判断数据的String类型字符串
     * @param pre 处理使用Predicate函数式接口
     * @return 判断接口是否满足要求，满足返回true，不满足返回false
     */
    public static boolean testPredicate(String str, Predicate<String> pre) {
        return pre.test(str);
    }
}
package com.qfedu.e_predicate;

import java.util.function.Predicate;

/**
 * Predicate and使用
 * default修饰方法add(Predicate<T> pre)
 *      and就是逻辑运算符里面的 &&
 *      同真为真，有假【即】假
 *      需要对两个Predicate进行判断处理
 *
 *      例如：
 *          pre1.test(str) && pre2.test(srt);
 *          ==> pre1.and(pre2).test(str);
 *
 * @author Anonymous 2020/3/11 16:19
 */
public class Demo2 {
    public static void main(String[] args) {

        /*
        这里需要量Predicate接口，使用Lambda
         */
        boolean ret = testAnd("赶紧复工吧，不要搞事情了！！！",
                str -> str.length() > 5,
                str -> str.startsWith("赶紧"));

        System.out.println(ret);
    }

    /**
     * 组合判断
     *
     * @param str  需要判断的字符串
     * @param pre1 判断方式1
     * @param pre2 判断方式2
     * @return 处理结果 true, false
     */
    public static boolean testAnd(String str, Predicate<String> pre1, Predicate<String> pre2) {
        // return pre1.test(str) && pre2.test(str)
        return pre1.and(pre2).test(str);
    }
}
package com.qfedu.e_predicate;

import java.util.function.Predicate;

/**
 * Predicate or演示
 *
 * @author Anonymous 2020/3/11 16:32
 */
public class Demo3 {
    public static void main(String[] args) {
        boolean ret = testOr("国家之强大，国外人羡慕不得~~",
                str -> str.length() < 10,
                str -> str.contains("国家"));

        System.out.println(ret);
    }

    /**
     * or 组合判断
     *
     * @param str  需要判断的字符串
     * @param pre1 判断方式1
     * @param pre2 判断方式2
     * @return 处理结果 true, false
     */
    public static boolean testOr(String str, Predicate<String> pre1, Predicate<String> pre2) {
        // return pre1.test(str) || pre2.test(str);
        return pre1.or(pre2).test(str);
    }
}
package com.qfedu.e_predicate;

import java.util.function.Predicate;

/**
 * Predicate negate()操作
 *
 * @author Anonymous 2020/3/11 16:36
 */
public class Demo4 {
    public static void main(String[] args) {
        boolean ret = testNegate("疫情总会过去的!!!",
                str -> str.length() < 5);
        System.out.println(ret);
    }

    /**
     * negate操作
     *
     * @param str 字符串
     * @param pre Predicate函数式接口
     * @return 处理结果
     */
    public static boolean testNegate(String str, Predicate<String> pre) {
        // return !pre.test(str);
        return pre.negate().test(str);
    }
}

ArrayList中使用Predicate删除指定数据

package com.qfedu.e_predicate;

import com.qfedu.c_supplier.Person;

import java.util.ArrayList;

/**
 * ArrayList，使用Predicate作为条件约束删除对应的数据
 *
 * @author Anonymous 2020/3/11 16:41
 */
public class Demo5 {
    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList<>();

        list.add(new Person(1, "骚磊", 16));
        list.add(new Person(2, "老黑", 66));
        list.add(new Person(3, "老付", 36));
        list.add(new Person(4, "老高", 26));
        list.add(new Person(5, "污云", 96));
        list.add(new Person(6, "帅栋", 96));

        // 直接安排Predicate函数式接口来约束对应的条件，进行删除操作
        // 代码的阅读性，普适性提升
        // 以及代码的冗余程度降低
        list.removeIf(person -> person.getAge() > 40 && person.getId() > 3);

        System.out.println(list);
    }
}

Function<T,R> 类型转换

使用R apply(T t)
转换指定类型T到R

package com.qfedu.f_function;

import com.qfedu.c_supplier.Person;

import java.util.function.Function;

/**
 * Function<T, R> 函数式接口
 *      R apply(T)
 *
 * @author Anonymous 2020/3/11 16:50
 */
public class Demo1 {
    public static void main(String[] args) {
        // Integer类型转换成一个String
        String change = change(10, i -> i + "");
        System.out.println(change);

        // 利用函数式接口处理一个String类型，转换成对应的Person类型
        Person person1 = change("1,骚磊,16", str -> {
            String[] split = str.split(",");
            Person person = new Person();

            person.setId(Integer.parseInt(split[0]));
            person.setName(split[1]);
            person.setAge(Integer.parseInt(split[2]));

            return person;
        });

        System.out.println(person1);
    }

    /**
     * 转换格式的方法，要求数据从Integer类型转换到指定的String类型
     *
     * @param i 需要转换的Integer类型
     * @param fun 转换使用的Function函数式接口
     * @return 返回值的是String类型
     */
    public static String change(Integer i, Function<Integer, String> fun) {
        return fun.apply(i);
    }

    public static Person change(String str, Function<String, Person> fun) {
        return fun.apply(str);
    }
}
package com.qfedu.f_function;

import java.util.function.Function;

/**
 * Function<T, R>
 *     default修饰andThen方法使用
 *
 * @author Anonymous 2020/3/11 17:01
 */
public class Demo2 {
    public static void main(String[] args) {
        String s = testAndThen(10,
                i -> i + "",
                i -> i + "测试");

        System.out.println(s);
    }

    /**
     * 两次转换过程
     *
     * @param i 需要处理的类型
     * @param fun1 Function函数接口
     * @param fun2 Function函数接口
     * @return String类型
     */
    public static String testAndThen(int i, Function<Integer, String> fun1, Function<String, String> fun2) {

        // andThen使用，最后apply方法参数类型是fun1要求的转换参数类型
        return fun1.andThen(fun2).apply(i);
    }
}
小太阳T'u'T
关注
java8新特性之FunctionalInterface
qq_33513250的博客
11-02 1488
一、概述 FunctionInterface函数接口是java8一个非常重要的新特性，它是一种指示性的类型注解，用于指示接口类型声明是由Java语言规范定义的功能接口。 从概念上讲，函数接口只有一个抽象方法。因为默认方法有一个实现，所以它们不是抽的。如果接口声明一个抽象方法覆盖Object对象的一个公共方法，则该方法也不计入接口的抽象方法计数，因为接口的任何实现都将具有来自Object对象或其他地方的实现。 请注意，可以使用lambda表达式、方法引用或构...
Java之函数式接口(FunctionalInterface)
我的博客
12-03 5231
Java之函数式接口 FunctionalInterface
Function函数式接口
yzx3105的博客
08-15 1710
视频讲解：https://ke.qq.com/webcourse/index.html?底层和Demo: 狂神JUC笔记：https://www.kuangstudy.com/bbs/1374936485165297666。
Function函数式接口使用
又要搬砖了
11-25 1325
Function函数式接口使用 文章目录Function函数式接口使用一、Function函数式接口介绍二、Supplier供给型函数1.Supplier介绍2.Supplier使用三、Consumer消费型函数1.Consumer介绍2.Consumer使用四、Runnable无参无返回型函数1.Runnable介绍2.Runnable使用五、Function有参有返回型函数1.Function介绍2.Function使用 一、Function函数式接口介绍 使用注解 @FunctionalInter
【Java 基础篇】Java Function 接口详解
繁依Fanyi的博客
09-24 1819
接口是 Java 8 引入的一个函数式接口，它定义了一个具有单一输入参数和单一结果返回的函数。该接口包含一个抽象方法apply(T t)，用于接受一个参数T并返回一个结果。T：表示输入参数的类型。R：表示结果类型的类型参数。Function接口的特点是它允许将一个函数作为参数传递，或者从函数返回一个结果，这使得它非常适合于函数式编程和各种数据处理操作。Function接口是 Java 编程中非常有用的一个函数式接口，它允许你定义和操作单一输入和输出的函数。通过创建Function。
Java常用的函数式接口
weixin_45736498的博客
02-17 192
常用的函数式接口 常用的函数式接口 接口 抽象方法 功能 Supplier< T>接口 T get() 用来获取一个泛型参数指定类型的对 象数据 Consumer< T>接口 void accept(T t) 消费一个指定泛型的数据 Predicate接口 boolean test(T t) 有时候我们需要对某种类型的数据进行判断，从而得到一个boo...
理解函数式接口 @FunctionalInterface
最新发布
wjianwei666的专栏
05-13 1182
在 Spring Boot 框架中，经常使用的 CommandLineRunner、ApplicationRunner 等等都是函数式接口。@FunctionalInterface 注解是 Java Lang 包中的一个注解，用于标识一个接口是函数式接口。在一些异步操作或模板方法中，我们可以使用函数式接口来传递回调函数，从而实现定制化的操作。在测试类的 main 方法中，我们使用 Lambda 表达式调用了函数式接口。以上就是函数式接口的整理，函数式接口是指只包含一个抽象方法的接口。
死磕Lambda表达式（四）：常用的函数式接口
01-20
在Java8支持Lambda表达式以后，为了满足Lambda表达式的一些典型使用场景，JDK为我们提供了大量常用的函数式接口。它们主要在 java.util.function 包中，下面简单介绍几个其中的接口及其使用示例。 Supplier接口 ...
基于Java8 函数式接口理解及测试
08-29
基于Java8 函数式接口理解及测试 本文主要介绍了 Java 8 中的函数式接口，包括其理解、定义、使用和测试。函数式接口是一种特殊的接口，仅包含一个抽象方法，可以被隐式转换为 lambda 表达式或方法引用。 函数式...
详解JAVA8 函数式接口
08-18
JAVA8 函数式接口是JAVA8中的一种重要特性，它提供了一些常用的函数式接口，极大的提高了我们的开发效率。在本文中，我们将详细介绍JAVA8 函数式接口的相关知识点，包括四大核心函数式接口和其他函数式接口，并提供...
函数式接口@FunctionalInterface使用示例
12-22
通过JDK8源码javadoc，可以知道@FunctionalInterface有以下特点： 该注解只能标记在”有且仅有一个抽象方法”的接口上，表示函数式接口。 JDK8接口中的静态方法和默认方法，都不算是抽象方法。 接口默认继承java.lang.Object,所以如果接口显示声明覆盖了Object中的方法，那么也不算抽象方法。 该注解不是必须的，如果一个接口符合”函数式编程”定义，那么加不加该注解都没有影响。加上该注解能够更好地让编译器进行检查，如果编写的不是函数式接口，但是加上了@FunctionalInterface 那么编译器会报错。 代码说明：使用Lambda表达式。一般的格式是
函数式编程lambda 和常用函数式接口
qq_40600507的博客
10-10 500
一. 函数式接口 概念：有且仅有一个抽象方法的接口，称之为函数式接口，可以包含其他方法（默认，静态的，私有的）。 适用于函数式编程场景的接口，Java中函数式编程体现为Lambda，函数式接口也可理解为适用于Lambda使用的接口。只有确保接口中有且仅有一个方法，Java中的Lambda才能顺利进行推导。 备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。 例如在遍历集合时使用的f...
jdk1.8之函数式接口
liu_shi_jun的专栏
01-10 1395
jdk1.8 函数式编程之Function , Consumer, Supplier, Predicate
函数式Function接口的应用
qq_41519943的博客
08-21 568
使用lambda表达式分别将以下功能封装到Function对象中            求Integer类型ArrayList中所有元素的平均数            将Map&lt;String,Integer&gt;中value存到ArrayList&lt;Integer&gt;中 已知学生成绩如下 姓名 成绩 岑小村 ...
@FunctionInterface
一个迷恋民谣的丑逼
06-08 3567
1.用在什么地方，有什么要求-用在接口上-接口内除object的public方法外，只有一个抽象方法@FunctionalInterface public interface Java8Interface { static void staticMethod(){//静态方法 System.out.println("staticMethod"); }; de...
使用Java8的函数式接口@FunctionalInterface实现简单异步调用
赵树祥的博客
01-30 1415
最近研究了一下异步调用，接下来几篇博客是跟异步调用相关的，首先使用@FunctionalInterface接口实现一个简单的步调用，也就是本篇博客主要内容。 然后再加上ZMQ，实现一个带网络通信的异步调用。再下一步就是复杂一点的RPC调用，最终目的是实现一个使用ZMQ的分布式调用系统。   Flag已经立，目标也定好了，先从简单的说起。   情景假设：假设一个程序需求是用户Person查看用
函数式接口@FunctionInterface
AllenLuoYi的博客
12-13 1231
java8提倡函数式编程，因而新增了一个函数式接口。函数式接口保证了函数式编程，同时也保证了能够兼容以前的java版本。 1.1 定义 在java8中，满足下面任意一个条件的接口都是函数式接口： 1、被@FunctionInterface注释的接口，满足@FunctionInterface注释的约束。 2、没有被@FunctionInterface注释的接口，但是满足@FunctionInterface注释的约束 1.2 @FunctionInterface注释的约束 1、接口有且只能有一个抽象方
Java8 常用FunctionInterface使用方法
lgx06的专栏
11-02 6314
package com.lgx.jdk8.part02; import java.util.*; import java.util.function.*; /** * java.util.function包API自学 */ public class Test06LearnBySelf { public static void main(String[] args) {
TypeScript篇.02-Interface接口,Class类,Function函数,Enum枚举,泛型
qq_54379580的博客
03-14 2132
关于ts中的接口, 类, 以及函数, 枚举, 泛型的简单介绍....
Java 8 函数式接口详解
常用函数式接口 - **Supplier**：无参数，返回一个结果。例如，`Supplier<String>`可以用来获取字符串。 - **Consumer**：接受一个参数，无返回值。通常用于消费一个对象，如打印日志。 - **Function**：接受一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值