经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
JAVA中的函数接口，你都用过吗
来源：cnblogs　　作者：架构成长指南　　时间：2023/11/20 8:56:57　　对本文有异议

公众号「架构成长指南」，专注于生产实践、云原生、分布式系统、大数据技术分享。

在这篇文章中，我们将通过示例来学习 Java 函数式接口。

函数式接口的特点

  1. 只包含一个抽象方法的接口称为函数式接口。
  2. 它可以有任意数量的默认静态方法，但只能包含一个抽象方法。它还可以声明对象类的方法。
  3. 函数接口也称为单一抽象方法接口或SAM 接口。
  4. 函数式接口只有在没有任何抽象方法时才可以扩展另一个接口。
  5. Java API 具有许多单方法接口，例如 Runnable、Callable、Comparator、ActionListener等。它们可以使用匿名类语法来实现和实例化。

接口示例

创建一个自定义的Sayable接口，这是一个使用@FunctionalInterface注解的函数式接口。
@FunctionalInterface注解表示该接口是一个函数式接口，并且只包含一个抽象方法。

自定义函数接口示例

  1. @FunctionalInterface  
  2. interface Sayable{  
  3.     void say(String msg);   // abstract method   
  4. }

让我们通过main()方法来演示一个自定义的函数式接口。我们使用Lambda表达式来实现函数式接口。

  1. public class FunctionalInterfacesExample {
  3.     public static void main(String[] args) {
  5.         Sayable sayable = (msg) -> {
  6.             System.out.println(msg);
  7.         };
  8.         sayable.say("Say something ..");
  9.     }
  10. }

Predefined 函数接口

Java提供了Predefined的函数式接口，通过使用 lambda 和方法引用来处理函数式编程。

Predicate是检查条件的函数，它接受一个参数并返回boolean结果。

让我们来看一下Predicate接口的内部实现。

  1. import java.util.function.Predicate;
  3. public interface Predicate<T> {
  4.     boolean test(T t);
  6.     default Predicate<T> and(Predicate<? super T> other) {
  7.         // 默认方法的实现
  8.         return (t) -> test(t) && other.test(t);
  9.     }
  11.     // 其他默认方法和静态方法...
  12. }

Predicate接口只包含一个抽象方法test(T t)同时它还包含默认方法和静态方法。

让我们创建一个示例来演示Predicate函数式接口的用法：

  1. import java.util.Arrays;
  2. import java.util.List;
  3. import java.util.function.Predicate;
  5. public class Main {
  6.     public static void main(String[] args) {
  7.         List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  9.         // 使用Predicate接口检查数字是否为偶数
  10.         Predicate<Integer> evenNumberPredicate = number -> number % 2 == 0;
  11.         System.out.println("Even numbers:");
  12.         printNumbers(numbers, evenNumberPredicate);
  14.         // 使用Predicate接口检查数字是否大于5
  15.         Predicate<Integer> greaterThanFivePredicate = number -> number > 5;
  16.         System.out.println("Numbers greater than 5:");
  17.         printNumbers(numbers, greaterThanFivePredicate);
  18.     }
  20.     public static void printNumbers(List<Integer> numbers, Predicate<Integer> predicate) {
  21.         for (Integer number : numbers) {
  22.             if (predicate.test(number)) {
  23.                 System.out.println(number);
  24.             }
  25.         }
  26.     }
  27. }

Function 函数接口

Function函数接口是Java中的一个函数式接口，它定义了一个接收一个参数并返回结果的函数。它的定义如下：

  1. @FunctionalInterface
  2. public interface Function<T, R> {
  3.     R apply(T t);
  4. }

Function接口有两个泛型参数：T表示输入参数的类型，R表示返回结果的类型。它包含一个抽象方法apply()，接收一个类型为T的参数，并返回一个类型为R的结果。

Function接口常用于将一个值转换为另一个值，或者对输入值进行处理和计算。它可以被用于各种场景，如数据转换、映射、计算和处理等。

以下是一个使用Function函数接口的示例：

  1. import java.util.function.Function;
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         // 创建一个Function接口来将字符串转换为大写
  6.         Function<String, String> uppercaseFunction = str -> str.toUpperCase();
  8.         // 使用Function接口将字符串转换为大写
  9.         String result = uppercaseFunction.apply("hello world");
  10.         System.out.println(result);  // 输出: HELLO WORLD
  12.         // 使用Function接口将字符串转换为其长度
  13.         Function<String, Integer> lengthFunction = str -> str.length();
  14.         int length = lengthFunction.apply("hello");
  15.         System.out.println(length);  // 输出: 5
  16.     }
  17. }

Supplier 函数接口

Supplier用于表示一个提供（供应）结果的函数。它通常用于延迟计算或在需要时生成值。通过调用get()方法，我们可以获取由Supplier实例提供的结果。

以下是Consumer接口的实现

  1. @FunctionalInterface
  2. public interface Supplier<T> {
  4.     /**
  5.      * Gets a result.
  6.      *
  7.      * @return a result
  8.      */
  9.     T get();
  10. }

由于Supplier接口只有一个抽象方法，因此可以使用lambda表达式快速创建Supplier实例。下面是一个示例：

  1. import java.util.Random;
  2. import java.util.function.Supplier;
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         // 创建一个Supplier接口来生成随机整数
  7.         Supplier<Integer> randomIntegerSupplier = () -> new Random().nextInt();
  9.         // 使用Supplier接口生成随机整数
  10.         int randomNumber = randomIntegerSupplier.get();
  11.         System.out.println(randomNumber);
  13.         // 创建一个Supplier接口来生成当前时间戳
  14.         Supplier<Long> timestampSupplier = () -> System.currentTimeMillis();
  16.         // 使用Supplier接口生成当前时间戳
  17.         long timestamp = timestampSupplier.get();
  18.         System.out.println(timestamp);
  19.     }
  20. }

Consumer 函数接口

Consumer用于表示接受一个参数并执行某些操作的函数。它定义了一个名为accept(T t)的抽象方法，接受一个参数，并且没有返回值。

以下是Consumer接口的简化版本

  1. @FunctionalInterface
  2. public interface Consumer<T> {
  3.     void accept(T arg0);
  4. }

Consumer接口适用于那些需要对传入的参数进行某种操作，而不需要返回结果的情况。它可以用于在不同的上下文中执行各种操作，如打印、修改状态、更新对象等。
下面是一个使用Consumer接口的示例：

  1. import java.util.Arrays;
  2. import java.util.List;
  3. import java.util.function.Consumer;
  5. public class Main {
  6.     public static void main(String[] args) {
  7.         List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Dave");
  9.         // 使用Consumer接口打印每个名字
  10.         Consumer<String> printName = name -> System.out.println(name);
  11.         names.forEach(printName);
  13.         // 使用Consumer接口修改每个名字为大写形式
  14.         Consumer<String> uppercaseName = name -> {
  15.             String uppercase = name.toUpperCase();
  16.             System.out.println(uppercase);
  17.         };
  18.         names.forEach(uppercaseName);
  19.     }
  20. }

在上述示例中，我们创建了两个Consumer接口的实例。第一个printName用于打印每个名字，第二个uppercaseName用于将每个名字转换为大写形式并打印。

通过调用forEach()方法并传入相应的Consumer接口实例，我们可以对列表中的每个元素执行相应的操作。在示例中，我们对名字列表中的每个名字进行了打印和转换操作。

Consumer接口的使用场景包括遍历集合、处理回调函数、更新对象状态等。它提供了一种简洁的方式来执行针对输入参数的操作，使得代码更加清晰和模块化。

BiFunction 函数接口

BiFunction函数式接口表示接受两个参数并返回结果的函数。它定义了一个名为apply(T t, U u)的抽象方法，接受两个参数，并返回一个结果。

让我们来看一下BiFunction接口的简化版本。

  1. @FunctionalInterface
  2. public interface BiFunction<T, U, R> {
  3.     R apply(T arg0, U arg1);
  4. }

BiFunction接口适用于那些需要接受两个输入参数并产生结果的情况。它可以用于执行各种操作，如计算、转换、筛选等。
下面是一个使用BiFunction接口的示例：

  1. import java.util.function.BiFunction;
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         // 使用BiFunction接口计算两个数的和
  6.         BiFunction<Integer, Integer, Integer> sumFunction = (a, b) -> a + b;
  7.         int sum = sumFunction.apply(5, 3);
  8.         System.out.println(sum);  // 输出: 8
  10.         // 使用BiFunction接口将两个字符串拼接起来
  11.         BiFunction<String, String, String> concatenateFunction = (str1, str2) -> str1 + str2;
  12.         String result = concatenateFunction.apply("Hello, ", "World!");
  13.         System.out.println(result);  // 输出: Hello, World!
  14.     }
  15. }

BiConsumer函数接口

BiConsumer接口，用于表示接受两个参数并执行某些操作的函数。它定义了一个名为accept(T t, U u)的抽象方法，接受两个参数，并且没有返回值。

以下是BiConsumer接口的简化版本：

  1. import java.util.function.BiConsumer;
  3. @FunctionalInterface
  4. public interface BiConsumer<T, U> {
  5.     void accept(T t, U u);
  6. }

BiConsumer接口适用于那些需要对传入的两个参数进行某种操作，而不需要返回结果的情况。它可以用于在不同的上下文中执行各种操作，如打印、修改状态、更新对象等。
下面是一个使用BiConsumer接口的示例：

  1. import java.util.function.BiConsumer;
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         // 使用BiConsumer接口打印两个数的和
  6.         BiConsumer<Integer, Integer> sumPrinter = (a, b) -> System.out.println(a + b);
  7.         sumPrinter.accept(5, 3);
  9.         // 使用BiConsumer接口打印两个字符串的拼接结果
  10.         BiConsumer<String, String> concatenationPrinter = (str1, str2) -> System.out.println(str1 + str2);
  11.         concatenationPrinter.accept("Hello, ", "World!");
  12.     }
  13. }
那些库或中间件再用BiConsumer

BiPredicate 函数接口

BiPredicate接口用于表示接受两个参数并返回一个布尔值的函数。它定义了一个名为test(T t, U u)的抽象方法，接受两个参数，并返回一个布尔值。

以下是BiPredicate接口的简化版本：

  1. @FunctionalInterface 
  2. public interface BiPredicate<T, U> {
  3.      boolean test(T t, U u);
  4.      // Default methods are defined also
  5. }

BiPredicate接口适用于那些需要对传入的两个参数进行某种条件判断，并返回布尔值的情况。它可以用于执行各种条件判断，如相等性比较、大小比较、复杂条件判断等。

下面是一个使用BiPredicate接口的示例：

  1. import java.util.function.BiPredicate;
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         // 使用BiPredicate接口判断两个数是否相等
  6.         BiPredicate<Integer, Integer> equalityPredicate = (a, b) -> a.equals(b);
  7.         boolean isEqual = equalityPredicate.test(5, 5);
  8.         System.out.println(isEqual);  // 输出: true
  10.         // 使用BiPredicate接口判断一个字符串是否包含另一个字符串
  11.         BiPredicate<String, String> containsPredicate = (str1, str2) -> str1.contains(str2);
  12.         boolean isContains = containsPredicate.test("Hello, World!", "World");
  13.         System.out.println(isContains);  // 输出: true
  14.     }
  15. }

原文链接：https://www.cnblogs.com/waldron/p/17841836.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号