编辑“︁Java Predicate接口”︁

{{Note|本教程适用于Java 8及以上版本。需要基础[[Java Lambda表达式]]知识。}}

= Java Predicate接口 =
'''Predicate<T>'''是Java 8引入的一个函数式接口，用于表示一个参数的布尔值函数（返回true或false）。它通常用于[[Lambda表达式]]和[[方法引用]]中，特别适合集合过滤、条件检查等场景。

== 接口定义 ==
源码定义（简化版）：
<syntaxhighlight lang="java">
@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
    
    // 默认方法
    default Predicate<T> and(Predicate<? super T> other) { /*...*/ }
    default Predicate<T> or(Predicate<? super T> other) { /*...*/ }
    default Predicate<T> negate() { /*...*/ }
}
</syntaxhighlight>

== 核心方法 ==
=== test() ===
基础方法，接受参数T并返回boolean：
<syntaxhighlight lang="java">
Predicate<String> isEmpty = s -> s.isEmpty();
System.out.println(isEmpty.test(""));      // 输出: true
System.out.println(isEmpty.test("Hello")); // 输出: false
</syntaxhighlight>

=== 组合方法 ===
==== and() ====
逻辑与操作：
<syntaxhighlight lang="java">
Predicate<Integer> isEven = n -> n % 2 == 0;
Predicate<Integer> isPositive = n -> n > 0;

System.out.println(isEven.and(isPositive).test(4));  // 输出: true
System.out.println(isEven.and(isPositive).test(-2)); // 输出: false
</syntaxhighlight>

==== or() ====
逻辑或操作：
<syntaxhighlight lang="java">
Predicate<String> startsWithA = s -> s.startsWith("A");
Predicate<String> endsWithZ = s -> s.endsWith("Z");

System.out.println(startsWithA.or(endsWithZ).test("Alpha")); // 输出: true
</syntaxhighlight>

==== negate() ====
逻辑非操作：
<syntaxhighlight lang="java">
Predicate<Double> isHighTemp = temp -> temp > 30.0;
System.out.println(isHighTemp.negate().test(25.0)); // 输出: true
</syntaxhighlight>

== 静态方法 ==
=== isEqual() ===
创建检查对象相等的Predicate：
<syntaxhighlight lang="java">
Predicate<String> isHello = Predicate.isEqual("Hello");
System.out.println(isHello.test("Hello")); // 输出: true
</syntaxhighlight>

== 实际应用案例 ==
=== 集合过滤 ===
结合Stream API使用：
<syntaxhighlight lang="java">
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
Predicate<Integer> isEven = n -> n % 2 == 0;

List<Integer> evens = numbers.stream()
                            .filter(isEven)
                            .collect(Collectors.toList());
// 输出: [2, 4, 6]
</syntaxhighlight>

=== 条件验证 ===
用户输入验证：
<syntaxhighlight lang="java">
public class UserValidator {
    private static final Predicate<String> isEmailValid = 
        email -> email.matches("^[\\w-.]+@([\\w-]+\\.)+[\\w-]{2,4}$");
    
    private static final Predicate<String> isPhoneValid = 
        phone -> phone.matches("^\\+?[0-9]{10,15}$");

    public static boolean validateContact(String input) {
        return isEmailValid.or(isPhoneValid).test(input);
    }
}
</syntaxhighlight>

== 高级用法 ==
=== Predicate组合 ===
动态构建复杂条件：
<syntaxhighlight lang="java">
Predicate<String> isAdmin = user -> user.startsWith("admin_");
Predicate<String> hasPermission = perm -> perm.contains("write");

Predicate<String> canEdit = user -> 
    isAdmin.test(user) || hasPermission.test(getUserPermissions(user));
</syntaxhighlight>

=== 方法引用 ===
与实例方法结合：
<syntaxhighlight lang="java">
List<String> names = Arrays.asList("Alice", "Bob", null, "Charlie");
Predicate<String> nonNull = Objects::nonNull;

long count = names.stream().filter(nonNull).count(); // 输出: 3
</syntaxhighlight>

== 性能考虑 ==
* 简单Predicate通常会被JIT编译器优化
* 复杂链式调用可能产生多个临时对象
* 对于高频操作，考虑缓存Predicate实例

== 常见误区 ==
{{Warning|1=
* 忘记Predicate是惰性求值，直到调用test()才会执行
* 在并行流中使用有状态的Predicate会导致不确定行为
* 过度组合可能导致代码可读性下降
}}

== 与其他接口对比 ==
{| class="wikitable"
|-
! 接口 !! 输入参数 !! 返回类型 !! 典型用途
|-
| Predicate<T> || T || boolean || 条件判断
|-
| Function<T,R> || T || R || 数据转换
|-
| Consumer<T> || T || void || 副作用操作
|-
| Supplier<T> || 无 || T || 值生成
|}

== 数学表达 ==
Predicate可视为数学中的特征函数：
<math>
\chi_A(x) = \begin{cases} 
1 & \text{当 } x \in A \\
0 & \text{当 } x \notin A 
\end{cases}
</math>

== 视觉表示 ==
<mermaid>
graph LR
    A[输入对象] --> B{Predicate.test}
    B -->|true| C[包含在结果中]
    B -->|false| D[被过滤掉]
</mermaid>

== 最佳实践建议 ==
# 优先使用静态final定义可重用Predicate
# 对复杂逻辑使用and()/or()组合而非嵌套if
# 为业务相关的Predicate起描述性名称
# 在Stream操作中保持Predicate无状态

{{JavaLambdaNavbox}}

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java Lambda表达式]]