【转】Predicate和Consumer接口– Java 8中java.util.function包下的接口

原文链接 http://ifeve.com/predicate-and-consumer-interface-in-java-util-function-package-in-java-8/

原文链接作者: Mohamed Sanaulla 译者: 李璟(jlee381344197@gmail.com)

早先我写了一篇《函数式接口》，探讨了部分Java 8中函数式接口的用法。我也提及了Predicate接口属于java.util.function包，

在这篇文章中，我将展示如何应用Predicate接口和Consumer接口。

一起看一下Predicate的官方文档：

Determines if the input object matches some criteria.

即判断输入的对象是否符合某个条件。

在Predicate接口中，有以下5个方法（你肯定好奇为何此接口属于函数式接口。如果你这么想，在使用接口前应该好好研读方法的注释）：

01
//Returns a predicate which evaluates to true only if this predicate

02
//and the provided predicate both evaluate to true.

03
and(Predicate<? super T> p) 

04
 
05
//Returns a predicate which negates the result of this predicate.

06
negate() 

07
 
08
//Returns a predicate which evaluates to true if either

09
//this predicate or the provided predicate evaluates to true

10
or(Predicate<? super T> p) 

11
 
12
//Returns true if the input object matches some criteria

13
test(T t) 

14
 
15
//Returns a predicate that evaluates to true if both or neither

16
//of the component predicates evaluate to true

17
xor(Predicate<? super T> p)

除了test()方法是抽象方法以外，其他方法都是默认方法（译者注：在Java 8中，接口可以包含带有实现代码的方法，这些方法称为default方法）。

可以使用匿名内部类提供test()方法的实现，也可以使用lambda表达式实现test()。

Consumer接口的文档声明如下：

An operation which accepts a single input argument and returns no result. Unlike most other functional interfaces,

Consumer is expected to operate via side-effects.

即接口表示一个接受单个输入参数并且没有返回值的操作。不像其他函数式接口，Consumer接口期望执行带有副作用的操作

（译者注：Consumer的操作可能会更改输入参数的内部状态）。

Consumer接口中有2个方法，有且只有一个声明为accept(T t)的方法，接收一个输入参数并且没有返回值。

为了详细说明Predicate和Consumer接口，我们来考虑一下学生的例子：Student类包含姓名，分数以及待付费用，

每个学生可根据分数获得不同程度的费用折扣。

01
class Student{

02
 
03
    String firstName;

04
 
05
    String lastName;

06
 
07
    Double grade;

08
 
09
    Double feeDiscount = 0.0;

10
 
11
    Double baseFee = 20000.0;

12
 
13
    public Student(String firstName, String lastName, Double grade) {

14
 
15
        this.firstName = firstName;

16
 
17
        this.lastName = lastName;

18
 
19
        this.grade = grade;

20
    }

21
 
22
    public void printFee(){

23
 
24
        Double newFee = baseFee - ((baseFee * feeDiscount) / 100);

25
 
26
        System.out.println("The fee after discount: " + newFee);

27
 
28
    }

29
 
30
}

我们分别声明一个接受Student对象的Predicate接口以及Consumer接口的实现类。如果你还不熟悉Function接口，

那么你需要花几分钟阅读一下这篇文章。这个例子使用Predicate接口实现类的test()方法判断输入的Student对象是否拥有费用打折的资格，

然后使用Consumer接口的实现类更新输入的Student对象的折扣。

01
public class PreidcateConsumerDemo {

02
 
03
   public static Student updateStudentFee(Student student, Predicate<Student> predicate, Consumer<Student> consumer){

04
 
05
        //Use the predicate to decide when to update the discount.

06
 
07
        if ( predicate.test(student)){

08
 
09
            //Use the consumer to update the discount value.

10
 
11
            consumer.accept(student);

12
        }

13
 
14
        return student;

15
 
16
    }

17
 
18
}

Predicate和Consumer接口的test()和accept()方法都接受一个泛型参数。不同的是test()方法进行某些逻辑判断并返回一个boolean值，

而accept()接受并改变某个对象的内部值。updateStudentFee方法的调用如下所示：

01
public static void main(String[] args) {

02
 
03
    Student student1 = new Student("Ashok","Kumar", 9.5);

04
 
05
    student1 = updateStudentFee(student1,

06
                                //Lambda expression for Predicate interface

07
                                student -> student.grade > 8.5,

08
                                //Lambda expression for Consumer inerface

09
                                student -> student.feeDiscount = 30.0);

10
 
11
    student1.printFee();

12
 
13
    Student student2 = new Student("Rajat","Verma", 8.0);

14
 
15
    student2 = updateStudentFee(student2,

16
                                student -> student.grade >= 8,

17
                                student -> student.feeDiscount = 20.0);

18
 
19
    student2.printFee();

20
 
21
}

原创文章，转载请注明： 转载自并发编程网 – ifeve.com

本文链接地址: Predicate和Consumer接口– Java 8中java.util.function包下的接口

李璟目前就职于深圳金斧子网络科技，关注Java、Python服务端开发

 1 package java.util.function;
 2 
 3 import java.util.Objects;
 4 
 5 /**
 6  * Represents a predicate (boolean-valued function) of one argument.
 7  *
 8  * <p>This is a <a href="package-summary.html">functional interface</a>
 9  * whose functional method is {@link #test(Object)}.
10  *
11  * @param <T> the type of the input to the predicate
12  *
13  * @since 1.8
14  */
15 @FunctionalInterface
16 public interface Predicate<T> {
17 
18     /**
19      * Evaluates this predicate on the given argument.
20      *
21      * @param t the input argument
22      * @return {@code true} if the input argument matches the predicate,
23      * otherwise {@code false}
24      */
25     boolean test(T t);
26 
27     /**
28      * Returns a composed predicate that represents a short-circuiting logical
29      * AND of this predicate and another.  When evaluating the composed
30      * predicate, if this predicate is {@code false}, then the {@code other}
31      * predicate is not evaluated.
32      *
33      * <p>Any exceptions thrown during evaluation of either predicate are relayed
34      * to the caller; if evaluation of this predicate throws an exception, the
35      * {@code other} predicate will not be evaluated.
36      *
37      * @param other a predicate that will be logically-ANDed with this
38      *              predicate
39      * @return a composed predicate that represents the short-circuiting logical
40      * AND of this predicate and the {@code other} predicate
41      * @throws NullPointerException if other is null
42      */
43     default Predicate<T> and(Predicate<? super T> other) {
44         Objects.requireNonNull(other);
45         return (t) -> test(t) && other.test(t);
46     }
47 
48     /**
49      * Returns a predicate that represents the logical negation of this
50      * predicate.
51      *
52      * @return a predicate that represents the logical negation of this
53      * predicate
54      */
55     default Predicate<T> negate() {
56         return (t) -> !test(t);
57     }
58 
59     /**
60      * Returns a composed predicate that represents a short-circuiting logical
61      * OR of this predicate and another.  When evaluating the composed
62      * predicate, if this predicate is {@code true}, then the {@code other}
63      * predicate is not evaluated.
64      *
65      * <p>Any exceptions thrown during evaluation of either predicate are relayed
66      * to the caller; if evaluation of this predicate throws an exception, the
67      * {@code other} predicate will not be evaluated.
68      *
69      * @param other a predicate that will be logically-ORed with this
70      *              predicate
71      * @return a composed predicate that represents the short-circuiting logical
72      * OR of this predicate and the {@code other} predicate
73      * @throws NullPointerException if other is null
74      */
75     default Predicate<T> or(Predicate<? super T> other) {
76         Objects.requireNonNull(other);
77         return (t) -> test(t) || other.test(t);
78     }
79 
80     /**
81      * Returns a predicate that tests if two arguments are equal according
82      * to {@link Objects#equals(Object, Object)}.
83      *
84      * @param <T> the type of arguments to the predicate
85      * @param targetRef the object reference with which to compare for equality,
86      *               which may be {@code null}
87      * @return a predicate that tests if two arguments are equal according
88      * to {@link Objects#equals(Object, Object)}
89      */
90     static <T> Predicate<T> isEqual(Object targetRef) {
91         return (null == targetRef)
92                 ? Objects::isNull
93                 : object -> targetRef.equals(object);
94     }
95 }