Java8 函数式接口Predicate学习

最近看了一下Java8的相关内容，个人感觉java8中引入的lambda表达式、函数式编程、Stream流以及日期时间的变化对于代码来说带来了很大的简洁性。往常我们是通过传递值或者对象，在java8以后我们可以传递行为，将要处理的动作传递过去，这个也是与以往的很大的不同。下面是我关于java8中函数式接口Predicate的学习和分享。

//表示Predicate是一个函数式接口
@FunctionalInterface
public interface Predicate<T> {

    /**
     * 测试该谓词与所给的参数是否匹配，返回一个boolean值
     *
     * @param t 输入的参数
     * @return 如果输入的参数与该谓词匹配，则返回true,否则返回false.
     */
    boolean test(T t);

    /**
     * 返回一个组合的谓词，它表示一个当前谓词与另外一个谓词的短路逻辑与AND。
     * 当测试该组合谓词的时候，如果当前的谓词返回值为false，那么另外一个谓词将不会参与测试。
     * 在评估任一谓词期间抛出的任何异常都会转发给调用者。如果当前的谓词抛出异常，那么另外
     * 一个谓词就不会被评测。
     * 
     * @param other 一个谓词将于当前的谓词进行逻辑与AND
     * @return 返回一个复合的谓词，表示当前谓词与另外一个谓词进行短路逻辑与后的结果
     * @throws 如果另外一个谓词为null，会抛出NullPointerException异常
     */
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        //此处返回值表达式里面使用了lambda表达式
        return (t) -> test(t) && other.test(t);
    }

    /**
     * 返回一个谓词，表示当前谓词的逻辑否
     * @return 返回一个谓词，表示当前谓词的逻辑否
     */
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    /**
     * 返回一个组合谓词，该谓词表示当前谓词与另一个谓词的短路逻辑或OR。当对组合谓词进行评测时，如果当前
     * 谓词为true,另外一个谓词就不会被评测。
     * 在评测期间任何抛出的异常都会转发给调用者。当评测组合谓词的时候，如果当前谓词是true，那么另外一个
     * 谓词就不会被评测。
     *
     * @param other 一个谓词将会与当前的谓词进行逻辑或
     * @return 返回一个组合的谓词表示当前谓词与另外一个谓词进行逻辑短路或的结果。
     * @throws 如果参数为NULL，则会抛出NullPointerException异常
     */
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    /**
     * 返回一个谓词，测试两个参数是否equals通过Object类的equals方法。
     * @param <T> 谓词的参数类型
     * @param targetRef用于比较相等性的对象引用，可以为null
     * @return 一个谓词，测试两个参数是否equals通过Object类的equals方法。
     */
    static <T> Predicate<T> isEqual(Object targetRef) {
        //此处调用了Objects类的isNull方法，如果该对象为null，就返回true,否则返回false
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }

    /**
     * 返回谓词，该谓词是提供的谓词的否定.
     * 通过调用target.negate()的返回值来完成的。
     * @param <T>     谓词具体的参数类型
     * @param target  谓词的否定
     *
     * @return 否定所提供谓词结果的谓词
     *
     * @throws 如果target为null,会抛出NullPointerException异常
     *
     * @since 11
     */
    @SuppressWarnings("unchecked")
    static <T> Predicate<T> not(Predicate<? super T> target) {
        Objects.requireNonNull(target);
        return (Predicate<T>)target.negate();
    }
}

package com.java8.learn;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

/**
 *@author:liyongyong
 *@description: Predicate函数接口的学习 根据用户指定的行为不同，来返回不同的结果集。
 *@date 2019/1/21
 */
public class PredicateTest {
    public static void main(String[] args){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        PredicateTest predicateTest = new PredicateTest();
        System.out.println("------------打印集合中所有偶数----------");
        predicateTest.conditionFilter(list,item->item%2 == 0);
        System.out.println("-------------打印集合中所有奇数---------");
        predicateTest.conditionFilter(list,item->item%2 != 0);
        System.out.println("---------打印集合中所有大于6的数-------------");
        predicateTest.conditionFilter(list,item->item>6);
        System.out.println("----------打印集合中所有小于4的数------------");
        predicateTest.conditionFilter(list,item->item<4);
        System.out.println("-----------打印集合中所有内容-----------");
        predicateTest.conditionFilter(list,item->true);
        System.out.println("-----------Predicate中and方法-----------");
        predicateTest.filterAnd(list,item->item>4,item->item%2 == 0);
        System.out.println("-----------Predicate中or方法-----------");
        predicateTest.filterOr(list,item->item>4,item->item%2 == 0);
        System.out.println("-----------Predicate中negate方法-----------");
        predicateTest.filterNegate(list,item->item>4,item->item%2 == 0);
        System.out.println("-----------Predicate中isEqual方法-----------");
        System.out.println(predicateTest.isEqual("test").test("test"));

    }

    /**
     * 根据传入的不同行为打印不同的内容
     * @param list 被操作的内容集合
     * @param predicate 用户所指定的行为
     */
    public  void  conditionFilter(List<Integer> list,Predicate<Integer> predicate){
        for (Integer num:list){
            if(predicate.test(num)){
                System.out.print(num + "    ");
            }
        }
        System.out.println();
    }

    public void filterAnd(List<Integer> list,Predicate<Integer> predicate1,Predicate<Integer> predicate2){
        for(Integer num:list){
            if(predicate1.and(predicate2).test(num)){
                System.out.print( num + "   ");
            }
        }
        System.out.println();
    }

    public void filterOr(List<Integer> list,Predicate<Integer> predicate1,Predicate<Integer> predicate2){
        for(Integer num:list){
            if(predicate1.or(predicate2).test(num)){
                System.out.print( num + "   ");
            }
        }
        System.out.println();
    }

    public void filterNegate(List<Integer> list,Predicate<Integer> predicate1,Predicate<Integer> predicate2){
        for(Integer num:list){
            if(predicate1.and(predicate2).negate().test(num)){
                System.out.print( num + "   ");
            }
        }
        System.out.println();
    }

    public Predicate<String> isEqual(Object object){
        return Predicate.isEqual(object);
    }
}

输出结果：

------------打印集合中所有偶数----------
2    4    6    8    10    
-------------打印集合中所有奇数---------
1    3    5    7    9    
---------打印集合中所有大于6的数-------------
7    8    9    10    
----------打印集合中所有小于4的数------------
1    2    3    
-----------打印集合中所有内容-----------
1    2    3    4    5    6    7    8    9    10    
-----------Predicate中and方法-----------
6   8   10   
-----------Predicate中or方法-----------
2   4   5   6   7   8   9   10   
-----------Predicate中negate方法-----------
1   2   3   4   5   7   9   
-----------Predicate中isEqual方法-----------
true

Java8 函数式接口Predicate学习

猜你喜欢