S13L07 - 谓词概述与 Lambda 表达式

html

掌握 Java Predicates：全面指南
目录

介绍 .............................................................. 2
理解 Java 中的 Predicates ............ 3

2.1 什么是 Predicate？ ............................................................ 3
2.2 Predicate 的类型 ............................................................. 4


使用 Lambda 表达式实现 Predicates ................................................................................................. 5

3.1 创建 IntPredicate ...................................................... 5
3.2 使用 Lambda 表达式简化测试 .............................. 6


高级 Predicate 操作 ............... 7

4.1 逻辑操作：AND, OR 和 NOT ................................... 7
4.2 组合 Predicates 以形成复杂条件 ........................... 8


实际示例和使用案例 ........... 9

5.1 验证用户输入 ............................................................ 9
5.2 过滤集合 ............................................................... 10


结论 ........................................................................ 11
附加资源 ...................................... 12

介绍
欢迎阅读 “掌握 Java Predicates：全面指南”。在 Java 编程世界中，predicates 是强大的工具，简化了在代码中评估条件和做出决策的过程。无论您是初学者刚进入 Java 领域，还是经验丰富的开发人员希望提升技能，理解 predicates 都能显著增强您编写清晰、高效和可读代码的能力。
本电子书深入探讨了 Java 中的 predicates 概念，探索了它们的类型、使用 lambda 表达式的实现以及高级操作。通过本指南，您将全面掌握如何利用 predicates 来简化编程任务，使您的应用程序更加稳健和易于维护。
涵盖的关键点：

介绍 predicates 及其在 Java 中的重要性
详细探讨不同类型的 predicates
使用 lambda 表达式逐步实现 predicates
使用 predicates 进行高级逻辑操作
实际示例和真实世界的使用案例
最佳实践和进一步学习的附加资源

让我们踏上掌握 Java predicates 的旅程，提升您的编程能力。
理解 Java 中的 Predicates
什么是 Predicate？
在 Java 中，predicate 是一个函数式接口，表示一个接受单一参数并返回布尔值的函数。基本上，predicates 用于评估条件，确定给定的输入是否满足某些标准。它们在需要根据特定条件过滤、测试或验证数据的场景中发挥关键作用。
Predicate<T> 接口位于 java.util.function 包中，定义如下：




		
		
			
			
Java
			
			
@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

			
				
					
				
					1
2
3
4
5
6
				
						 
@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}
 
					
				
			
		


这里，T 代表 predicate 输入的类型。主要方法 test(T t) 根据定义的条件评估给定参数上的 predicate，并返回 true 或 false。
Predicate 的类型
Java 提供了各种针对不同数据类型的专用 predicates，增强了性能和类型安全性。最常用的 predicates 包括：

Generic Predicate (Predicate<T>)：适用于任何对象类型。
IntPredicate (IntPredicate)：专用于 int 基本类型。
LongPredicate (LongPredicate)：专用于 long 基本类型。
DoublePredicate (DoublePredicate)：专用于 double 基本类型。

通过选择适当的 predicate 类型，您可以针对特定数据类型优化代码，减少装箱和拆箱基本类型的开销。


Predicate 类型
描述
专用于


Predicate<T>
适用于任何对象类型的通用 predicate
任何对象类型


IntPredicate
适用于 int 值的 predicate
int 基本类型


LongPredicate
适用于 long 值的 predicate
long 基本类型


DoublePredicate
适用于 double 值的 predicate
double 基本类型


在本指南中，我们将重点关注 IntPredicate，以演示 predicates 如何与基本数据类型协同工作，确保高效和类型安全的操作。
使用 Lambda 表达式实现 Predicates
创建 IntPredicate
实现一个 predicate 包含定义输入必须满足的条件。让我们探讨如何创建一个测试给定整数是否小于 18 的 IntPredicate。




		
		
			
			
Java
			
			
import java.util.function.IntPredicate;

public class Main {
    public static void main(String[] args) {
        IntPredicate isLessThan18 = new IntPredicate() {
            @Override
            public boolean test(int value) {
                if (value < 18) {
                    return true;
                } else {
                    return false;
                }
            }
        };

        System.out.println(isLessThan18.test(10)); // Output: true
        System.out.println(isLessThan18.test(20)); // Output: false
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
				
						 
import java.util.function.IntPredicate;
 
public class Main {
    public static void main(String[] args) {
        IntPredicate isLessThan18 = new IntPredicate() {
            @Override
            public boolean test(int value) {
                if (value < 18) {
                    return true;
                } else {
                    return false;
                }
            }
        };
 
        System.out.println(isLessThan18.test(10)); // Output: true
        System.out.println(isLessThan18.test(20)); // Output: false
    }
}
 
					
				
			
		


解释：

Import Statement：我们从 java.util.function 导入 IntPredicate。
Creating the Predicate：我们创建了一个名为 isLessThan18 的 IntPredicate 实例。该 predicate 覆盖了 test 方法，以检查输入的 value 是否小于 18。
Testing the Predicate：我们用值 10 和 20 测试 predicate，分别返回 true 和 false。

使用 Lambda 表达式简化测试
虽然上述实现有效，但 Java 的 lambda 表达式提供了一种更简洁和可读的定义 predicate 的方式。让我们使用 lambda 表达式重构前面的示例。




		
		
			
			
Java
			
			
import java.util.function.IntPredicate;

public class Main {
    public static void main(String[] args) {
        IntPredicate isLessThan18 = value -> value < 18;

        System.out.println(isLessThan18.test(10)); // Output: true
        System.out.println(isLessThan18.test(20)); // Output: false
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						 
import java.util.function.IntPredicate;
 
public class Main {
    public static void main(String[] args) {
        IntPredicate isLessThan18 = value -> value < 18;
 
        System.out.println(isLessThan18.test(10)); // Output: true
        System.out.println(isLessThan18.test(20)); // Output: false
    }
}
 
					
				
			
		


解释：

Lambda Expression：不仅创建匿名内部类，我们使用 lambda 表达式 value -> value < 18 来定义 predicate。
Conciseness：这种方法减少了样板代码，使 predicate 定义更加简洁且易于阅读。

高级 Predicate 操作
逻辑操作：AND, OR 和 NOT
Java 的 Predicate 接口提供了默认方法，如 and()、or() 和 negate()，用于组合 predicates。

and(Predicate other)：用逻辑 AND 组合两个 predicates。
or(Predicate other)：用逻辑 OR 组合两个 predicates。
negate()：反转 predicate 的结果。





		
		
			
			
Java
			
			
import java.util.function.IntPredicate;

public class Main {
    public static void main(String[] args) {
        IntPredicate isLessThan18 = value -> value < 18;
        IntPredicate isGreaterThan18 = value -> value > 18;

        // AND operation
        IntPredicate between15And20 = isLessThan18.and(isGreaterThan18);
        System.out.println(between15And20.test(17)); // Output: false

        // OR operation
        IntPredicate isTeenager = isLessThan18.or(isGreaterThan18);
        System.out.println(isTeenager.test(20)); // Output: true

        // NOT operation
        IntPredicate isNotLessThan18 = isLessThan18.negate();
        System.out.println(isNotLessThan18.test(10)); // Output: false
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						 
import java.util.function.IntPredicate;
 
public class Main {
    public static void main(String[] args) {
        IntPredicate isLessThan18 = value -> value < 18;
        IntPredicate isGreaterThan18 = value -> value > 18;
 
        // AND operation
        IntPredicate between15And20 = isLessThan18.and(isGreaterThan18);
        System.out.println(between15And20.test(17)); // Output: false
 
        // OR operation
        IntPredicate isTeenager = isLessThan18.or(isGreaterThan18);
        System.out.println(isTeenager.test(20)); // Output: true
 
        // NOT operation
        IntPredicate isNotLessThan18 = isLessThan18.negate();
        System.out.println(isNotLessThan18.test(10)); // Output: false
    }
}
 
					
				
			
		


解释：

AND Operation：between15And20 使用 and() 将 isLessThan18 和 isGreaterThan18 组合起来。由于一个数字不可能同时小于和大于 18，因此总是返回 false。
OR Operation：isTeenager 使用 or() 组合两个 predicates。如果任一条件为 true，则返回 true。
NOT Operation：isNotLessThan18 反转 isLessThan18 predicate 的结果。

组合 Predicates 以形成复杂条件
通过组合 predicates，您可以构建适应特定需求的复杂条件。让我们创建一个 predicate，检查一个数字是否在 10 到 20 之间。




		
		
			
			
Java
			
			
import java.util.function.IntPredicate;

public class Main {
    public static void main(String[] args) {
        IntPredicate isGreaterThan10 = value -> value > 10;
        IntPredicate isLessThan20 = value -> value < 20;

        IntPredicate isBetween10And20 = isGreaterThan10.and(isLessThan20);

        System.out.println(isBetween10And20.test(15)); // Output: true
        System.out.println(isBetween10And20.test(25)); // Output: false
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						 
import java.util.function.IntPredicate;
 
public class Main {
    public static void main(String[] args) {
        IntPredicate isGreaterThan10 = value -> value > 10;
        IntPredicate isLessThan20 = value -> value < 20;
 
        IntPredicate isBetween10And20 = isGreaterThan10.and(isLessThan20);
 
        System.out.println(isBetween10And20.test(15)); // Output: true
        System.out.println(isBetween10And20.test(25)); // Output: false
    }
}
 
					
				
			
		


解释：

Defining Individual Predicates：我们定义了 isGreaterThan10 和 isLessThan20 来检查单个条件。
Combining with AND：通过使用 and()，isBetween10And20 仅在满足两个条件时返回 true。

实际示例和使用案例
理解 predicates 不仅是理论上的；将其应用于真实世界的场景展示了它们的实用性和有效性。让我们探讨一些 predicates 发挥重要作用的实际使用案例。
验证用户输入
假设您正在开发一个需要根据特定标准验证用户输入的应用程序。predicates 可以简化这一验证过程。




		
		
			
			
Java
			
			
import java.util.function.Predicate;

public class InputValidator {
    public static void main(String[] args) {
        Predicate<String> isNotEmpty = input -> !input.isEmpty();
        Predicate<String> hasMinimumLength = input -> input.length() >= 5;
        Predicate<String> containsSpecialCharacter = input -> input.matches(".*[!@#$%^&*()].*");

        Predicate<String> isValid = isNotEmpty.and(hasMinimumLength).and(containsSpecialCharacter);

        String userInput1 = "Passw@rd";
        String userInput2 = "1234";

        System.out.println(isValid.test(userInput1)); // Output: true
        System.out.println(isValid.test(userInput2)); // Output: false
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						 
import java.util.function.Predicate;
 
public class InputValidator {
    public static void main(String[] args) {
        Predicate<String> isNotEmpty = input -> !input.isEmpty();
        Predicate<String> hasMinimumLength = input -> input.length() >= 5;
        Predicate<String> containsSpecialCharacter = input -> input.matches(".*[!@#$%^&*()].*");
 
        Predicate<String> isValid = isNotEmpty.and(hasMinimumLength).and(containsSpecialCharacter);
 
        String userInput1 = "Passw@rd";
        String userInput2 = "1234";
 
        System.out.println(isValid.test(userInput1)); // Output: true
        System.out.println(isValid.test(userInput2)); // Output: false
    }
}
 
					
				
			
		


解释：

Defining Predicates：我们定义了 predicates 来检查输入是否不为空、长度是否至少为 5 且是否包含至少一个特殊字符。
Combining Predicates：isValid predicate 使用 and() 组合这些条件。
Testing Inputs：

userInput1 = "Passw@rd" 满足所有条件，因此 isValid.test(userInput1) 返回 true。
userInput2 = "1234" 未满足最小长度和特殊字符条件，结果为 false。



过滤集合
在处理集合时，predicates 是无价的，允许根据特定标准进行高效过滤。




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

public class CollectionFilter {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 12, 17, 22, 29, 10, 15);

        Predicate<Integer> isEven = number -> number % 2 == 0;
        Predicate<Integer> isGreaterThan15 = number -> number > 15;

        List<Integer> filteredNumbers = numbers.stream()
                .filter(isEven.and(isGreaterThan15))
                .collect(Collectors.toList());

        System.out.println(filteredNumbers); // Output: [22]
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
				
						 
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
 
public class CollectionFilter {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 12, 17, 22, 29, 10, 15);
 
        Predicate<Integer> isEven = number -> number % 2 == 0;
        Predicate<Integer> isGreaterThan15 = number -> number > 15;
 
        List<Integer> filteredNumbers = numbers.stream()
                .filter(isEven.and(isGreaterThan15))
                .collect(Collectors.toList());
 
        System.out.println(filteredNumbers); // Output: [22]
    }
}
 
					
				
			
		


解释：

Defining Predicates：我们定义了 predicates 来检查一个数字是否为偶数以及是否大于 15。
Filtering the Collection：使用 Java Streams，我们通过应用组合 predicate isEven.and(isGreaterThan15) 来过滤 numbers 列表。
Result：只有 22 满足两个条件，结果是包含 [22] 的列表。

结论
Predicates 是 Java 函数式编程范式中的基本组成部分，提供了一种简洁而强大的方式来评估条件并在代码中做出决策。通过利用 predicates，特别是结合 lambda 表达式，开发人员可以编写更具可读性、高效且易于维护的代码。
关键要点：

灵活性：Predicates 可以使用逻辑运算符 (and、or、negate) 组合，以形成复杂条件。
类型安全性：像 IntPredicate 这样的专用 predicates 在处理基本数据类型时增强了类型安全性和性能。
简洁性：Lambda 表达式简化了 predicate 的定义，减少了样板代码，增强了可读性。
实用性：从验证用户输入到过滤集合，predicates 在各种编程场景中都有广泛应用。

随着您不断提升 Java 技能，将 predicates 集成到编码实践中无疑将有助于编写更清晰和高效的代码。拥抱 predicates 的力量，开启编程能力的新高度。
附加资源

官方 Java Predicate 文档
Java Lambda 表达式教程
Java 中的函数式编程
Stream API 和 Predicates
Joshua Bloch 的《Effective Java》

注意：本文为 AI 生成。
Predicate 类型	描述	专用于
Predicate<T>	适用于任何对象类型的通用 predicate	任何对象类型
IntPredicate	适用于 int 值的 predicate	int 基本类型
LongPredicate	适用于 long 值的 predicate	long 基本类型
DoublePredicate	适用于 double 值的 predicate	double 基本类型