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

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

 

原文链接 作者:   Mohamed Sanaulla  译者: 李璟([e-mail])

早先我写了一篇《函数式接口》，探讨了部分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服务端开发

 

 

package java.util.function;

import java.util.Objects;

/**
 * Represents a predicate (boolean-valued function) of one argument.
 *
 * <p>This is a <a href="package-summary.html">functional interface</a>
 * whose functional method is {@link #test(Object)}.
 *
 * @param <T> the type of the input to the predicate
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Predicate<T> {

    /** 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 
    /**
     * Returns a composed predicate that represents a short-circuiting logical
     * AND of this predicate and another.  When evaluating the composed
     * predicate, if this predicate is {@code false}, then the {@code other}
     * predicate is not evaluated.
     *
     * <p>Any exceptions thrown during evaluation of either predicate are relayed
     * to the caller; if evaluation of this predicate throws an exception, the
     * {@code other} predicate will not be evaluated.
     *
     * @param other a predicate that will be logically-ANDed with this
     *              predicate
     * @return a composed predicate that represents the short-circuiting logical
     * AND of this predicate and the {@code other} predicate
     * @throws NullPointerException if other is null
     */
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    /**
     * Returns a predicate that represents the logical negation of this
     * predicate.
     *
     * @return a predicate that represents the logical negation of this
     * predicate
     */
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    /**
     * Returns a composed predicate that represents a short-circuiting logical
     * OR of this predicate and another.  When evaluating the composed
     * predicate, if this predicate is {@code true}, then the {@code other}
     * predicate is not evaluated.
     *
     * <p>Any exceptions thrown during evaluation of either predicate are relayed
     * to the caller; if evaluation of this predicate throws an exception, the
     * {@code other} predicate will not be evaluated.
     *
     * @param other a predicate that will be logically-ORed with this
     *              predicate
     * @return a composed predicate that represents the short-circuiting logical
     * OR of this predicate and the {@code other} predicate
     * @throws NullPointerException if other is null
     */
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    /**
     * Returns a predicate that tests if two arguments are equal according
     * to {@link Objects#equals(Object, Object)}.
     *
     * @param <T> the type of arguments to the predicate
     * @param targetRef the object reference with which to compare for equality,
     *               which may be {@code null}
     * @return a predicate that tests if two arguments are equal according
     * to {@link Objects#equals(Object, Object)}
     */
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}