Java 集合系列（6）： Predicate接口源码 && Consumer接口源码

package java.util.function;

import java.util.Objects;

/**
 * Predicate功能判断输入的对象是否符合某个条件
 * @since 1.8
 */

@FunctionalInterface
public interface Predicate<T> {      //Predicate函数编程

    
    boolean test(T t);

    
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

   
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

lambda表达式

从上面代码可以发现，Java 8新增了接口的默认(default)方法和(static)静态方法。在Java 8以前，接口里的方法要求全部是抽象方法。但是静态(static)方法只能通过接口名调用，不可以通过实现类的类名或者实现类的对象调用；默认(default)方法只能通过接口实现类的对象来调用。

接下来主要来使用接口方法test，可以使用匿名内部类提供test()方法的实现，也可以使用lambda表达式实现test()。 
体验一下Predicate的函数式编程，使用lambda实现。其测试代码如下：

package com.fengxiyuma.kuanjia;

public class Java8Tester {
    public static void main(String[] args) {
    	
    	 //-----------------------------------------------------------------------
        java.util.function.Predicate<Integer> boolValue = x -> x > 5;
        System.out.println(boolValue.test(1));//false
        System.out.println(boolValue.test(6));//true
        //-----------------------------------------------------------------------
    	
    	
    	
    	Java8Tester tester = new Java8Tester();
        
        // 类型声明
        MathOperation addition = (int a, int b) -> a + b;
          
        // 不用类型声明
        MathOperation subtraction = (a, b) -> a - b;
          
        // 大括号中的返回语句
        MathOperation multiplication = (int a, int b) -> { return a * b; };
          
        // 没有大括号及返回语句
        MathOperation division = (int a, int b) -> a / b;
          
        System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
        System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
        System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
        System.out.println("10 / 5 = " + tester.operate(10, 5, division));
          
        // 不用括号
        GreetingService greetService1 = message ->
        System.out.println("Hello " + message);
          
        // 用括号
        GreetingService greetService2 = (message) ->
        System.out.println("Hello " + message);
          
        greetService1.sayMessage("Runoob");
        greetService2.sayMessage("Google");
     }
      
     interface MathOperation {
        int operation(int a, int b);
     }
      
     interface GreetingService {
        void sayMessage(String message);
     }
      
     private int operate(int a, int b, MathOperation mathOperation){
        return mathOperation.operation(a, b);
     }
}

结果：

false
true
10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2
Hello Runoob
Hello Google

Consumer接口源码：

/** 
 * 代表一个操作，这个操作接受单一输入参数并且不返回任何结果。不像其它大多数函数接口，Consumer被 
 * 期望通过副作用操作。（通过副作用操作时什么意思？） 
 * 
 *这是一个函数接口，它函数方法是accept（Object）。 
 */  
@FunctionalInterface  
public interface Consumer<T> {  
  
    /** 
     * 对给定参数执行这个操作 
     */  
    void accept(T t);  
  
    /** 
     * 返回一个组合的Consumer，它依次执行这个操作和after操作。如果任何一个操作抛出异常，异常 
     * 会被传递给组合操作的调用者。如果执行这个操作抛出异常，after操作将不会被执行。 
     */  
    default Consumer<T> andThen(Consumer<? super T> after) {  
        Objects.requireNonNull(after);  
        return (T t) -> { accept(t); after.accept(t); };  
    }  
}  

从上面代码可以看出，Consumer使用了Java 8接口新特性——接口默认(default)方法。接下来使用接口方法accept，体验一下Consumer函数编程。其测试代码如下：（还要想想，直接贴其他人的代码了）

@Test
public void testConsumer(){
    User user = new User("zm");
    //接受一个参数
    Consumer<User> userConsumer = User1 -> User1.setName("zmChange");
    userConsumer.accept(user);
    System.out.println(user.getName());//zmChange
}

在Java 8之前的实现如下：

@Test
public void test(){
    User user = new User("zm");
    this.change(user);
    System.out.println(user.getName());//输出zmChange
}

private void change(User user){
    user.setName("zmChange");
}

参考：http://www.runoob.com/java/java8-lambda-expressions.html

          https://blog.csdn.net/anonymousprogrammer/article/details/76034393

          https://blog.csdn.net/chuji2012/article/details/77871011

          https://blog.csdn.net/l294265421/article/details/45131731