Java8常用的内置函数式接口（一）Predicate、Consumer、Supplier、Function

Java8常用的内置函数式接口（一）

简介

• JDK 1.8 API中包含了很多内置的函数式接口。有些是在以前版本的Java中大家耳熟能详的，例如Comparator接口，或者Runnable接口。对这些现成的接口进行实现，可以通过@FunctionalInterface 标注来启用Lambda功能支持。
• 此外，Java 8 API 还提供了很多新的函数式接口，来降低程序员的工作负担。
• 比如我们今天要了解到的四大常用的内置函数式接口：下表

序号	接口名	接口类型
1	Predicate	断言型接口
2	Consumer	消费型接口
3	Supplier	供给型接口
4	Function<T, R>	函数式接口

• JDK 1.8之前已有的函数式接口

  java.lang.Runnable
  
  java.util.concurrent.Callable
  
  java.security.PrivilegedAction
  
  java.util.Comparator
  
  java.io.FileFilter
  
  java.nio.file.PathMatcher
  
  java.lang.reflect.InvocationHandler
  
  java.beans.PropertyChangeListener
  
  java.awt.event.ActionListener
  
  javax.swing.event.ChangeListener

Predicate 断言型接口

---

Predicate是一个断言式的函数式接口，返回的是一个boolean值，用于进行判断行为与参数是否相符。Java8Stream中的filter使用的就是此函数式接口。

Predicate是一个布尔类型的函数，该函数只有一个输入参数。Predicate接口包含了多种默认方法，用于处理复杂的逻辑动词（and, or，negate）

Predicate常用方法

1. test()方法

---

test源码：


/**
* Evaluates this predicate on the given argument.
*
* @param t the input argument
* @return {@code true} if the input argument matches the predicate,
* otherwise {@code false}
*/
boolean test(T t);// 用来判断传过来的参数是否符合规则


test方法的作用是:

1 . 评估参数里面的表达式(说白了就是验证传进来的参数符不符合规则)

2 . 它的返回值是一个boolean类型(这点需要注意一下)。

测试示例代码：

//传入一个字符串，test方法判断该字符串长度是否大于2
@Test
public void test1(){
Predicate<String> predicate = (s) -> s.length() > 2;
boolean foo = predicate.test("foo");// true
}


2.and()方法（默认方法）

---

and源码：


/**
* 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);
//通过源码我们可以看到，return最总返回的是并且的逻辑，必须满足两个条件,等同于我们的逻辑与&&,存在短路特性
}


• 注意：and 方法返回一个Predicate<? super T>
  
  测试示例代码：

//通过调用下面的方法，我们将and和test方法连续使用
boolean b = testAndMethod("zhangssss",
stringOne -> stringOne.equals("zhangsan"), stringTwo -> stringTwo.length() > 5);
System.out.println("测试and方法打印结果："+b); /**
*
* @param stringOne 待判断的字符串
* @param predicateOne 断定表达式1
* @param predicateTwo 断定表达式2
* @return 是否满足两个条件
*/
public boolean testAndMethod(String stringOne, Predicate<String> predicateOne,Predicate<String> predicateTwo) { return predicateOne.and(predicateTwo).test(stringOne);//and 方法返回一个Predicate<? super T>
}
打印结果：
测试and方法打印结果：false
因为使用and方法同时需要满足两个条件


3.negate()方法（默认方法）

---

negate源码：

/**
* 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);
//我们可以看到return返回的是test()方法的相反结果，等同于我们的逻辑非
}


返回值一样需要注意， 是Predicate

测试示例代码：

//测试negate()和test()
boolean f = testNageteMethod("zhangsan", stringOne -> stringOne.equals("zhangsan"));
System.out.println("测试negate方法打印结果："+f); public boolean testNageteMethod(String stringValue, Predicate<String> predicate) {
return predicate.negate().test(stringValue);
}
打印结果：
测试negate方法打印结果：false


4.or()方法（默认方法）

---

or源码：

/**
* 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);
//通过return我们可以看出返回的是多者选其一即可， 等同于我们的逻辑或
}


返回值一样需要注意，Predicate

测试示例代码：

//测试or方法
boolean a = testOrMethod("zhangsan"
, stringOne -> stringOne.equals("zhangsan111")
, stringTwo -> stringTwo.length() > 50
, stringThree -> stringThree.length() % 2 == 0);
System.out.println("测试or方法打印结果："+a);
public boolean testOrMethod(String stringOne, Predicate<String> predicateOne, Predicate<String> predicateTwo, Predicate<String> predicateThree) { return predicateOne.or(predicateTwo).or(predicateThree).test(stringOne);
}


5. isEqual()方法(静态方法)

---

判断两个对象是否相等—> 使用的是Objects里面的equals()方法进行比较

isEqual源码：

/**
* 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);
}


解释如下: 本类由一些操作对象的静态工具方法构成，这些工具方法包括了非空检查、方法的非空参数检查、比较对象的hashCode、为对象返回一个字符串表示、比较两个对象,说的很明显了，比较的两个对象的HashCode值

通俗一点解释: 先判断对象是否为NULL—> 这个由Objects里面的isNull进行判断,如果，不为Null的话,那么接下来用java.lang.object里面的equals()方法进行比较.

测试示例代码：

//测试isEqual()方法
System.out.println(testMethodIsEquals("zhangsan","zhangsan"));
System.out.println("~~~ ~~~ ~~~ ~~~");
System.out.println(testMethodIsEquals("zhangsan","lisi"));
System.out.println("~~~ ~~~ ~~~ ~~~");
System.out.println(testMethodIsEquals(null,"zhangsan")); /* 我们来Debug一下这个程序*/ public boolean testMethodIsEquals(String strValue, String strValue2) { return Predicate.isEqual(strValue).test(strValue2);
}

Consumer 消费型接口

---

Consumer的作用顾名思义,是给定义一个参数,对其进行(消费)处理,处理的方式可以是任意操作.

接口源码：

@FunctionalInterface
public interface Consumer<T> { void accept(T t); default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}


Consumer常用方法

---

1.accept()方法

accept源码：

/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);


accept(T t),接受一个参数，没有返回值

测试示例代码：

List<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9);
// 通过lambda表达式构造出Consumer对象
Consumer listener = i -> System.out.println(i);
list.forEach(listener);


上面是通过lambda表达式构造出Consumer对象，将list中每一个元素，传递给consumer,执行打印的操作，我再把这个例子做一个变化

// 通过lambda表达式构造出Consumer对象
list.forEach(i -> System.out.println(i * 2));


这里打印的元素是乘2后的结果，这就说明了通过lambda表达式，我们传递的是行为，accept(T t)方法只负责接收一个参数，至于要做什么，是我们再调用的时候，把行为传递过去。

另外还可以使用方法引用的方式来调用Consumer的accept方法。

// 通过方法引用的方式构造出Consumer对象
list.forEach(System.out::println);


这里也可以实现遍历每一个元素并打印出来，这是通过方法引用的方式来构造出的Consumer对象。"::"这里两个连续的冒号，是jdk8支持的语法,可以自动定位到具体的函数式接口，这里就可以自动定位到Consumer。

2. andThen()方法

---

andThen源码：

/**
* Returns a composed {@code Consumer} that performs, in sequence, this
* operation followed by the {@code after} operation. If performing either
* operation throws an exception, it is relayed to the caller of the
* composed operation. If performing this operation throws an exception,
* the {@code after} operation will not be performed.
*
* @param after the operation to perform after this operation
* @return a composed {@code Consumer} that performs in sequence this
* operation followed by the {@code after} operation
* @throws NullPointerException if {@code after} is null
*/
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}

该方法默认实现，它接收一个Consumer对象，同时会返回一个Consumer对象,返回的Consumer对象还可以继续调用andThen方法，这样该方法就实现了将执行操作给串行化。举个例子：

print(list, item -> System.out.print(" consumer1-->:" + item * 2), item -> System.out.println(" consumer2-->:" + item * 3)); /*
andThen方法， 将参数传递给调用者执行accept方法，然后再传给第二个consumer执行accept方法。
*/
public void print(List<Integer> list, IntConsumer con1, IntConsumer con2) {
list.forEach(item -> con1.andThen(con2).accept(item));
}


该示例构造了两个Consumer对象,通过consumer的andThen方法，将两个操作给串行起来，对于list中每个元素，都会先执行con1的appect方法，再执行con2的accept方法。

打印结果：
consumer1-->:2 consumer2-->:3
consumer1-->:4 consumer2-->:6
consumer1-->:6 consumer2-->:9
consumer1-->:8 consumer2-->:12
consumer1-->:10 consumer2-->:15
consumer1-->:12 consumer2-->:18
consumer1-->:14 consumer2-->:21
consumer1-->:16 consumer2-->:24
consumer1-->:18 consumer2-->:27


与Consumer相关的接口

BiConsumer<T, U>

• 处理一个两个参数

DoubleConsumer

• 处理一个double类型的参数

IntConsumer

• 处理一个int类型的参数

LongConsumer

• 处理一个long类型的参数

ObjIntConsumer

• 处理两个参数,且第二个参数必须为int类型

ObjLongConsumer

• 处理两个参数,且第二个参数必须为long类型

Supplier供给型接口

---

Supplier接口是对象实例的提供者，定义了一个名叫get的抽象方法，它没有任何入参，并返回一个泛型T对象，具体源码如下：

@FunctionalInterface
public interface Supplier<T> { /**
* Gets a result.
*
* @return a result
*/
T get();
}


常用方法

1. get()方法

下面我们使用声明一个Supplier的实例：

/**
*supplier供给型函数接口测试
*/
@Test
public void testSupplier() {
Supplier<Person> supplier = Person::new;
Person person = supplier.get();
System.out.println("通过Supplier接口创建Person空对象："+person);
System.out.println("---------------------------"); Supplier<Person> supplier1 =() -> new Person("Evonne", "Shari", "JAVA", "female", 40, 1800);
Person person1 = supplier1.get();
System.out.println("通过Supplier接口创建Person非空对象："+person1);
}


打印结果：
通过Supplier接口创建Person空对象：Person(firstName=null, lastName=null, job=null, gender=null, salary=0, age=0)
---------------------------
通过Supplier接口创建Person非空对象：Person(firstName=Evonne, lastName=Shari, job=JAVA, gender=female, salary=40, age=1800)


特别需要注意的是，本例中每一次调用get方法都会创建新的对象。

Function<T,R>函数式接口

Function接口可以创建更加复杂的Function接口实例。有两个参数：T入参，R返参

常用方法

1. apply()方法

---

Function 就是一个函数，其作用类似于数学中函数的定义，所以Function中没有具体的操作，具体的操作需要我们去为它指定，因此apply具体返回的结果取决于传入的lambda表达式。

apply源码：

/**
* Applies this function to the given argument.
*
* @param t the function argument
* @return the function result
*/
R apply(T t);


测试示例代码：

public void test(){
Function<Integer,Integer> test=i->i+1;
test.apply(5);
}
/**打印结果 print:6*/


解析：上面的示例用lambda表达式定义了一个行为使得i自增1，我们使用参数5(相当于传入参数5)执行apply，最后打印结果6。这跟我们以前看待Java的眼光已经不同了，在函数式编程之前我们定义一组操作首先想到的是定义一个方法，然后指定传入参数，返回我们需要的结果。函数式编程的思想是先不去考虑具体的行为，而是先去考虑参数，具体的方法我们可以后续再设置。

再举个例子：

public void test(){
Function<Integer,Integer> test1=i->i+1;
Function<Integer,Integer> test2=i->i*i; System.out.println(calculate(test1,5));
System.out.println(calculate(test2,5));
}
public static Integer calculate(Function<Integer,Integer> test,Integer number){
return test.apply(number);
}
/** 打印结果print:6*/
/**打印结果 print:25*/


通过传入不同的Function，实现了在同一个方法中实现不同的操作。在实际开发中这样可以大大减少很多重复的代码，比如我在实际项目中有个新增用户的功能，但是用户分为VIP和普通用户，且有两种不同的新增逻辑。那么此时我们就可以先写两种不同的逻辑。除此之外，这样还让逻辑与数据分离开来，我们可以实现逻辑的复用。

当然实际开发中的逻辑可能很复杂，比如两个方法F1,F2都需要两个个逻辑AB，但是F1需要A->B，F2方法需要B->A。这样的我们用刚才的方法也可以实现，源码如下：

public void test(){
Function<Integer,Integer> A=i->i+1;
Function<Integer,Integer> B=i->i*i;
System.out.println("F1:"+B.apply(A.apply(5)));
System.out.println("F2:"+A.apply(B.apply(5)));
}
/** F1:36 */
/** F2:26 */

2 . compose()和andThen()方法

接着上面的例子，假如我们F1,F2需要四个逻辑ABCD，那我们还这样写就会变得很麻烦了。

compose和andThen可以解决我们的问题。先看compose的源码：

default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));//before，先执行传入的V，在执行原有的
}


compose接收一个Function参数，返回时先用传入的逻辑执行apply，然后使用当前Function的apply。

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));//after,先执行原有的，再执行传入的参数
}


andThen跟compose正相反，先执行当前的逻辑，再执行传入的逻辑

换个说法：

compose等价于B.apply(A.apply(5))，而andThen等价于A.apply(B.apply(5))。

public void test(){
Function<Integer,Integer> A=i->i+1;
Function<Integer,Integer> B=i->i*i;
System.out.println("F1:"+B.apply(A.apply(5)));
System.out.println("F1:"+B.compose(A).apply(5));
System.out.println("F2:"+A.apply(B.apply(5)));
System.out.println("F2:"+B.andThen(A).apply(5));
}
/** F1:36 */
/** F1:36 */
/** F2:26 */
/** F2:26 */


我们可以看到上述两个方法的返回值都是一个Function，这样我们还可以使用建造者模式（待研究）的操作来使用。

Integer apply1 = B1.compose(A1).compose(A1).andThen(A1).apply(5);//待研究


结束语

至此，对于函数式接口有了一个初步认识，革命向未成功，同志仍需努力。

推荐参考blog:

Function接口的使用

死磕Lambda表达式