Java Predicate及Consumer接口函数代码实现解析

Java中的Predicate和Consumer是两种常用的函数式接口，它们可以让我们编写更为简洁、灵活的代码，特别是在处理集合、流等数据时非常有用。

Predicate

Predicate可以理解为谓词或者断言，它接受一个输入参数，返回一个布尔类型的值。通常情况下，我们使用Predicate来过滤集合或者流中的数据。

下面是Predicate接口的定义：

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

其中，@FunctionalInterface注解表示该接口是一个函数式接口，只有一个抽象方法test。

为了方便我们使用Predicate，Java也提供了一些默认方法，例如and（与）、or（或）、negate（非）等方法。

下面是一个简单的示例，使用Predicate过滤出大于10的数字：

List<Integer> numbers = Arrays.asList(1, 20, 25, 8, 15, 30);

Predicate<Integer> greaterThanTen = n -> n > 10;

List<Integer> filtered = numbers.stream().filter(greaterThanTen).collect(Collectors.toList());

System.out.println(filtered); // [20, 25, 15, 30]

这段代码中，我们定义了一个Predicate greaterThanTen，它的test方法会判断传入的参数是否大于10。然后，我们将这个Predicate作为过滤条件，使用stream的filter方法对numbers集合进行过滤，最后通过collect方法将符合条件的数据收集到一个新的集合中。

除了单独使用Predicate以外，我们还可以使用and、or、negate等方法来组合多个Predicate，用于实现更为复杂的条件。例如，下面的代码使用and方法组合了两个Predicate：

List<Integer> numbers = Arrays.asList(1, 20, 25, 8, 15, 30);

Predicate<Integer> greaterThanTen = n -> n > 10;
Predicate<Integer> lessThanTwenty = n -> n < 20;

List<Integer> filtered = numbers.stream().filter(greaterThanTen.and(lessThanTwenty)).collect(Collectors.toList());

System.out.println(filtered); // [15]

在上面的代码中，我们使用and方法将greaterThanTen和lessThanTwenty组合成一个新的Predicate，然后使用filter方法进行过滤，最终得到符合条件的数据集合。

Consumer

Consumer接口表示接受一个参数并且没有返回值的函数。它可以被用于处理集合、流等数据，进行一些副作用的操作，例如打印输出、更新数据等等。

下面是Consumer接口的定义：

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

其中，Consumer接口只有一个抽象方法accept。

除了accept方法以外，Java还提供了一些默认方法，例如andThen方法，用于将两个Consumer组合起来形成一个新的Consumer。

下面是一个实例，展示如何使用Consumer接口对数据进行一些操作：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

Consumer<Integer> print = n -> System.out.print(n + " ");
Consumer<Integer> multiply = n -> System.out.print(n * 2 + " ");

numbers.forEach(print.andThen(multiply)); // 1 2 3 4 5 2 4 6 8 10

这段代码中，我们定义了两个Consumer，一个是print，用于打印输出，另一个是multiply，用于将输入参数乘以2并打印输出。然后，我们使用forEach方法对numbers集合进行遍历，将print和multiply组合成一个新的Consumer，并将其作为参数传递给forEach方法，在遍历过程中依次执行两个Consumer的操作。

再举一个例子，假设我们有一个Cat类，它包含了name和age属性：

public class Cat {
    private String name;
    private int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

我们可以使用Consumer来对Cat对象进行一些操作，例如更新name和age属性：

Cat cat = new Cat("Mimi", 2);

Consumer<Cat> update = c -> {
    c.setName("Tom");
    c.setAge(3);
};

System.out.println("Before update: " + cat.getName() + ", " + cat.getAge()); // Before update: Mimi, 2

update.accept(cat);

System.out.println("After update: " + cat.getName() + ", " + cat.getAge()); // After update: Tom, 3

在上面的代码中，我们定义了一个Consumer update，用于更新Cat对象的name和age属性。然后，我们将update作为参数传递给accept方法，对cat对象进行了更新操作，从而得到了更新后的结果。

以上就是Predicate和Consumer接口的简单介绍和示例代码。借助于这两个接口，我们可以编写更为灵活、简洁的代码，提高编码效率和维护性。