深入理解 Java 的 Predicate 接口组合

潜意识Java

于 2025-06-23 20:50:58 发布

阅读量405

点赞数 8

CC 4.0 BY-SA版权

分类专栏： Java知识文章标签： java python 开发语言

本文链接：https://blog.csdn.net/weixin_73355603/article/details/148854174

Java知识专栏收录该内容

334 篇文章

订阅专栏

在 Java 8 引入的函数式编程范式中，Predicate<T> 接口扮演着至关重要的角色。它不仅可以表示简单的条件判断，还能通过组合操作构建复杂的逻辑表达式。本文将从基础概念入手，逐步深入探讨 Predicate 接口的组合能力及其在实际开发中的应用。

一、Predicate 接口基础

Predicate<T> 是一个函数式接口，位于 java.util.function 包中，其核心方法是：

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
    
    // 默认方法：逻辑与
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
    
    // 默认方法：逻辑或
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
    
    // 默认方法：逻辑非
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
    
    // 静态方法：判断相等
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

二、基本组合操作

1. 逻辑与（and）

// 定义两个简单的 Predicate
Predicate<String> startsWithA = s -> s.startsWith("A");
Predicate<String> hasLength3 = s -> s.length() == 3;

// 组合为 "以A开头且长度为3" 的条件
Predicate<String> combined = startsWithA.and(hasLength3);

// 测试
System.out.println(combined.test("ABC")); // true
System.out.println(combined.test("AB"));  // false
System.out.println(combined.test("BCD")); // false

2. 逻辑或（or）

// 组合为 "以A开头或以B开头" 的条件
Predicate<String> startsWithA = s -> s.startsWith("A");
Predicate<String> startsWithB = s -> s.startsWith("B");
Predicate<String> combined = startsWithA.or(startsWithB);

// 测试
System.out.println(combined.test("ABC")); // true
System.out.println(combined.test("BCD")); // true
System.out.println(combined.test("CDE")); // false

3. 逻辑非（negate）

// 定义 "长度大于5" 的条件并取反
Predicate<String> lengthGreaterThan5 = s -> s.length() > 5;
Predicate<String> lengthLessOrEqual5 = lengthGreaterThan5.negate();

// 测试
System.out.println(lengthLessOrEqual5.test("Hello"));  // true
System.out.println(lengthLessOrEqual5.test("World!")); // false

三、多条件复杂组合

通过链式调用，可以构建更加复杂的条件表达式：

// 组合示例：(A && B) || (!C && D)
Predicate<Integer> isEven = num -> num % 2 == 0;
Predicate<Integer> isPositive = num -> num > 0;
Predicate<Integer> isGreaterThan10 = num -> num > 10;
Predicate<Integer> isLessThan5 = num -> num < 5;

Predicate<Integer> complexCondition = isEven
        .and(isPositive)
        .or(isGreaterThan10.negate().and(isLessThan5));

// 测试
System.out.println(complexCondition.test(4));   // true (满足 isEven && isPositive)
System.out.println(complexCondition.test(12));  // true (满足 isEven && isPositive)
System.out.println(complexCondition.test(-3));  // false (不满足任何分支)
System.out.println(complexCondition.test(3));   // true (满足 !isGreaterThan10 && isLessThan5)

四、静态方法：isEqual

Predicate.isEqual 用于创建基于对象相等性的 Predicate：

// 判断字符串是否等于 "test"
Predicate<String> isTest = Predicate.isEqual("test");

// 测试
System.out.println(isTest.test("test"));  // true
System.out.println(isTest.test("TEST"));  // false

// 判断对象是否相等
class Person {
    private String name;
    public Person(String name) { this.name = name; }
    // equals 和 hashCode 方法
}

Person p1 = new Person("Alice");
Person p2 = new Person("Alice");
Person p3 = new Person("Bob");

Predicate<Person> isAlice = Predicate.isEqual(p1);
System.out.println(isAlice.test(p2)); // true (假设 equals 方法已正确实现)
System.out.println(isAlice.test(p3)); // false

五、在 Stream API 中的应用

Predicate 最常见的应用场景是在 Stream 过滤操作中：

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class StreamFilterExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "avocado", "cherry", "apricot");
        
        // 组合过滤条件：长度大于5且以a开头
        Predicate<String> lengthGreaterThan5 = s -> s.length() > 5;
        Predicate<String> startsWithA = s -> s.startsWith("a");
        
        List<String> result = words.stream()
                .filter(lengthGreaterThan5.and(startsWithA))
                .collect(Collectors.toList());
        
        System.out.println(result); // 输出：[avocado, apricot]
    }
}

六、动态条件构建

在实际应用中，我们经常需要根据运行时条件动态构建 Predicate：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class DynamicPredicateExample {
    public static void main(String[] args) {
        List<String> data = Arrays.asList("apple", "banana", "avocado", "cherry", "apricot");
        
        // 动态构建条件
        boolean includeA = true;
        boolean lengthGreaterThan5 = false;
        
        Predicate<String> condition = Predicate.isEqual(""); // 初始化为始终false的条件
        
        if (includeA) {
            condition = condition.or(s -> s.startsWith("a"));
        }
        
        if (lengthGreaterThan5) {
            condition = condition.or(s -> s.length() > 5);
        }
        
        // 如果没有设置任何条件，则返回所有元素
        if (condition.test("")) {
            condition = s -> true;
        }
        
        List<String> result = data.stream()
                .filter(condition)
                .collect(Collectors.toList());
        
        System.out.println(result); // 根据条件动态变化
    }
}

七、最佳实践与注意事项

避免空指针异常
在组合 Predicate 时，确保每个条件都能正确处理 null 值：

// 安全的 Predicate 定义
Predicate<String> safeStartsWithA = s -> s != null && s.startsWith("A");

逻辑优先级
注意组合时的逻辑优先级，必要时使用括号明确分组：

// 正确分组示例
Predicate<Integer> complex = (even.and(positive)).or(greaterThan10);

性能考虑
避免创建过于复杂的 Predicate 组合，可能导致代码可读性下降。可以将复杂逻辑分解为多个命名清晰的 Predicate。

重用与复用
将常用的 Predicate 定义为静态常量，提高代码复用性：

public class Predicates {
    public static final Predicate<String> IS_EMPTY = String::isEmpty;
    public static final Predicate<String> NOT_EMPTY = IS_EMPTY.negate();
}