【Java8新特性】04 详解Lambda表达式中Predicate Function Consumer Supplier函数式接口

简介: 【Java8新特性】04 详解Lambda表达式中Predicate Function Consumer Supplier函数式接口

Java8 由Oracle在2014年发布,是继Java5之后最具革命性的版本。

Java8吸收其他语言的精髓带来了函数式编程,lambda表达式,Stream流等一系列新特性,学会了这些新特性,可以让你实现高效编码优雅编码。


函数式接口


函数式接口是指只定义了一个抽象方法的接口,不包括default默认方法。


函数式接口的抽象方法的签名称为函数描述符,通过函数描述符可以很好得到Lambda表达式的签名。


常见的函数式接口有:Runnable, Callable, Comparator等。除此之外,Java8设计者还新增了一些比较抽象的函数式接口,比如:Predicate, Consumer, Supplier, Function, UnaryOperator, BinaryOperator等, 这些函数式接口定义在java.util.function包中。


接下来详细介绍function包中定义的抽象接口:


1. Predicate


(1)定义

Predicate是谓词的意思,用来判断泛型T对象是否符合条件,如果符合返回true,否则返回false。


查看jdk源码,定义了一个抽象方法test:

@FunctionalInterface
public interface Predicate<T> {
    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
}


(2)使用方法

Predicate是一个接口所以不能直接实例化,可以使用匿名类或者Lambda表达式实例化。以Lambda为例:

// 接收string对象,判断是否为空,返回boolean
Predicate predicate = (String str) -> str.isEmpty();

下面以一个校验参数的实例说明:

@Test
public void testPredicate() {
    String input = "hello java8";
    if (validate(input, (str) -> !str.isEmpty() && str.length() > 5)) {
        // 校验输入
        System.out.println("valid input");
    }
}
// 第二个参数接收一个Predicate实例
private <T> boolean validate(T input, Predicate<T> predicate) {
    return predicate.test(input);
}


(3)函数描述符

Predicate: T -> boolean


接受泛型T对象返回boolean。


注意:java.util.function包中还针对基本类型封装了类似IntPredicate, LongPredicate等接口,这无非是表明只接受Int或Long类型的输入,后面Consumer等函数式接口与这个类似,本文不再赘述。


2. Consumer


(1)定义

Consumer是消费者的意思,用来接收一个泛型T对象,执行相关操作,最后返回void。


查看jdk源码,定义了一个抽象方法accept:

@FunctionalInterface
public interface Consumer<T> {
    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
}


(2)使用方法

使用Lambda表达式实例化Consumer接口:

Consumer<String> consumer = (str) -> System.out.println(str);


下面以打印字符串的实例讲解Consumer的用法:

@Test
public void testConsumer() {
    String input = "hello java8";
    // 打印输入
    consume(input, (str) -> System.out.println(str));
}
private <T> void consume(T input, Consumer<T> consumer) {
    consumer.accept(input);
}


(3)函数描述符

Consumer: T -> void

接受泛型T对象返回void。


3. Supplier


(1)定义

Supplier是提供者的意思,用来生成泛型T对象。

查看jdk源码,定义了一个抽象方法get:

@FunctionalInterface
public interface Supplier<T> {
    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}


(2)使用方法

使用Lambda表达式实例化Supplier接口:

Supplier supplier = () -> "Hello Java8 supplier";


下面以获取当前时间的实例讲解Supplier的用法:

@Test
public void testSupplier() {
    // 获取当前时间
    Long currentTime = supply(() -> System.currentTimeMillis());
}
private <T> T supply(Supplier<T> supplier) {
    return supplier.get();
}


(3)函数描述符

Supplier: void -> T

接受void返回泛型T对象。


4. Function


(1)定义

Function是函数的意思,用来定义一个抽象函数,接收泛型T对象,返回泛型R对象。

查看jdk源码,定义了一个抽象方法apply:

@FunctionalInterface
public interface Function<T, R> {
    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
}


(2)使用方法

使用Lambda表达式实例化Function接口:

Function<String, Integer> function = (str) -> str.length();


下面以判断输入是否以指定字符串开头的实例讲解Function的用法:

@Test
public void testFunction() {
    String input = "hello java8";
    if(func(input, (String str) -> str.startsWith("hello"))) {
        System.out.println("start with hello");
    }
}
private <T, R> R func(T t, Function<T, R> function) {
    return function.apply(t);
}


(3)函数描述符

Function: T -> R

接受泛型T对象,返回泛型R对象。


5. UnaryOperator


(1)定义

UnaryOperator是一元操作符的意思,接收一个泛型T对象参数,返回相同T类型对象。

查看jdk源码,UnaryOperator继承自Function接口,定义了一个identity方法:

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
    /**
     * Returns a unary operator that always returns its input argument.
     *
     * @param <T> the type of the input and output of the operator
     * @return a unary operator that always returns its input argument
     */
    static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}


(2)使用方法

使用Lambda表达式实例化UnaryOperator接口:

UnaryOperator<Integer> unaryOperator = (Integer i) -> i * i;


下面以整数递增的实例讲解UnaryOperator的用法:

@Test
public void testUnaryOperator() {
    UnaryOperator<Integer> unaryOperator = (Integer i) -> i * i;
    int input = 0;
    int result = unaryOperate(input, (Integer i) -> i + 1);
    // output: 1
    System.out.println(result);
}
private <T> T unaryOperate(T t, UnaryOperator<T> unaryOperator) {
    return unaryOperator.apply(t);
}


(3)函数描述符

UnaryOperator: T -> T

接受泛型T对象,返回泛型T对象。


6. BinaryOperator


(1)定义

BinaryOperator是二元操作符的意思,接收两个相同泛型参数类型T,返回R类型对象。

查看jdk源码,BinaryOperator继承自BiFunction接口,继承了BiFunction的apply方法:

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
    /**
     * Applies this function to the given arguments.
     *
     * @param t the first function argument
     * @param u the second function argument
     * @return the function result
     */
    R apply(T t, U u);
}


(2)使用方法

使用Lambda表达式实例化BinaryOperator接口:

BinaryOperator<String> binaryOperator = (String str1, String str2) -> str1 + str2;


下面以整数求和实例讲解BinaryOperator的用法:

@Test
public void testBinaryOperator() {
    int a1 = 10;
    int a2 = 20;
    int sum = binaryOperate(a1, a2, (Integer i1, Integer i2) -> i1 + i2);
    // output: 30
    System.out.println(sum);
}
private <T> T binaryOperate(T t1, T t2, BinaryOperator<T> binaryOperator) {
    return binaryOperator.apply(t1, t2);
}


(3)函数描述符

BinaryOperator: (T, T) -> T

接受两个泛型T对象,返回一个泛型T对象。


7. 总结


java.util.function包中定义了很多函数式抽象接口,只要记住它们的函数描述符就可以很方便的知道他们的使用方法。

  • Predicate: T -> boolean
  • Consumer: T -> void
  • Supplier: void -> T
  • Function: T -> R
  • UnaryOperator: T -> T
  • BinaryOperator: (T, T) -> T


相关文章
|
5天前
|
Java API 开发者
Java中的Lambda表达式与函数式编程####
在Java的演变过程中,Lambda表达式和函数式编程的引入无疑是一次重大的飞跃。本文将深入探讨Lambda表达式的定义、用法及优势,并结合实例说明如何在Java中利用Lambda表达式进行函数式编程。通过对比传统编程方式,揭示Lambda表达式如何简化代码、提高开发效率和可维护性。 ####
|
13天前
|
自然语言处理 安全 Java
Aviator Java 表达式引擎
AviatorScript 是一门高性能、轻量级寄宿于 JVM 之上的脚本语言。
30 10
|
11天前
|
Java API 数据处理
探索Java中的Lambda表达式与Stream API
【10月更文挑战第22天】 在Java编程中,Lambda表达式和Stream API是两个强大的功能,它们极大地简化了代码的编写和提高了开发效率。本文将深入探讨这两个概念的基本用法、优势以及在实际项目中的应用案例,帮助读者更好地理解和运用这些现代Java特性。
|
15天前
|
存储 Java API
优雅地使用Java Map,通过掌握其高级特性和技巧,让代码更简洁。
【10月更文挑战第19天】本文介绍了如何优雅地使用Java Map,通过掌握其高级特性和技巧,让代码更简洁。内容包括Map的初始化、使用Stream API处理Map、利用merge方法、使用ComputeIfAbsent和ComputeIfPresent,以及Map的默认方法。这些技巧不仅提高了代码的可读性和维护性,还提升了开发效率。
36 3
|
15天前
|
Java API
[Java]Lambda表达式
本文主要介绍了Java中的Lambda表达式,包括其优化匿名内部类的方式、使用规范、内置函数式接口及方法引用等内容。文章详细解析了Lambda的基础语法、参数列表、方法体的简化规则,以及如何利用Lambda优化代码。此外,还探讨了Lambda的作用域和引用规则,强调了对局部变量、成员变量和常量的访问限制,旨在帮助读者全面理解和掌握Lambda表达式的应用。
11 0
[Java]Lambda表达式
|
12天前
|
监控 安全 Java
在 Java 中使用线程池监控以及动态调整线程池时需要注意什么?
【10月更文挑战第22天】在进行线程池的监控和动态调整时,要综合考虑多方面的因素,谨慎操作,以确保线程池能够高效、稳定地运行,满足业务的需求。
91 38
|
9天前
|
安全 Java
java 中 i++ 到底是否线程安全?
本文通过实例探讨了 `i++` 在多线程环境下的线程安全性问题。首先,使用 100 个线程分别执行 10000 次 `i++` 操作,发现最终结果小于预期的 1000000,证明 `i++` 是线程不安全的。接着,介绍了两种解决方法:使用 `synchronized` 关键字加锁和使用 `AtomicInteger` 类。其中,`AtomicInteger` 通过 `CAS` 操作实现了高效的线程安全。最后,通过分析字节码和源码,解释了 `i++` 为何线程不安全以及 `AtomicInteger` 如何保证线程安全。
java 中 i++ 到底是否线程安全?
|
4天前
|
存储 设计模式 分布式计算
Java中的多线程编程:并发与并行的深度解析####
在当今软件开发领域,多线程编程已成为提升应用性能、响应速度及资源利用率的关键手段之一。本文将深入探讨Java平台上的多线程机制,从基础概念到高级应用,全面解析并发与并行编程的核心理念、实现方式及其在实际项目中的应用策略。不同于常规摘要的简洁概述,本文旨在通过详尽的技术剖析,为读者构建一个系统化的多线程知识框架,辅以生动实例,让抽象概念具体化,复杂问题简单化。 ####
|
5天前
|
Java 开发者
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
23 4
|
5天前
|
消息中间件 供应链 Java
掌握Java多线程编程的艺术
【10月更文挑战第29天】 在当今软件开发领域,多线程编程已成为提升应用性能和响应速度的关键手段之一。本文旨在深入探讨Java多线程编程的核心技术、常见问题以及最佳实践,通过实际案例分析,帮助读者理解并掌握如何在Java应用中高效地使用多线程。不同于常规的技术总结,本文将结合作者多年的实践经验,以故事化的方式讲述多线程编程的魅力与挑战,旨在为读者提供一种全新的学习视角。
25 3