Java8新特性（一）Lambda表达式之函数式接口

---

---

一、自定义函数式接口

函数式接口 (Functional Interface) 就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
函数式接口是为了lambda 表达式服务，函数式接口的存在是 lambda 表达式出现的前提，接下来我们先介绍下函数式接口。

---

首先我们来看一下，如何定义一个函数式接口:

• 这个接口具有唯一的一个抽像方法sayMessage()
• 不能在函数式接口中定义多个抽象方法，但可以定义默认方法、静态方法、定义java.lang.Object里的public方法。

1、自定义一个函数式接口

package com._520xuzai.lambda;

//可以使用@FunctionalInterface注解修饰，对该接口做检查；如果接口里，有多个抽象方法，使用该注解，会有语法错误。
@FunctionalInterface
public interface IFunctionTest<T> {

    void sayMessage(T x);

//    void sayMessage2(T x); //这个接口必须具有唯一的一个抽像方法

    default void doSomeWork1(){
        // Method body
    }

    default void doSomeWork2(){
        // Method body
    }

    static void printHello(){
        System.out.println("Hello");
    }

    static void printHello2(){
        System.out.println("Hello2");
    }

    @Override
    boolean equals(Object obj);

}

2、定义一个函数式接口实现类

为便于更好的理解，我们同时定义一个接口实现类作为演示

package com._520xuzai.lambda.impl;

import com._520xuzai.lambda.IFunctionTest;

public class FunctionTestImpl<T> implements IFunctionTest<T> {

    @Override
    public void sayMessage(T x) {

        System.out.println(x);

    }


}

3、实践和理解

package com._520xuzai.lambda;

import com._520xuzai.lambda.impl.FunctionTestImpl;

public class FunctionTestMain {

    public static void main(String[] args) {

        //使用匿名内部类的方式
        IFunctionTest<String> functionTest2 = new IFunctionTest<String>() {
            @Override
            public void sayMessage(String x) {
                System.out.println(x);

            }
        };
        functionTest2.sayMessage("自定义函数式接口2");

        //定义实现类方式
        IFunctionTest<String> functionTest3 = new FunctionTestImpl<>();
        functionTest3.sayMessage("自定义函数式接口3");

        //使用lambda表达式的方式
        IFunctionTest<String> functionTest = str -> System.out.println(str);
        functionTest.sayMessage("自定义函数式接口");

    }
}

二、java内置的函数式接口

1、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

2、JDK 1.8 新增加的函数接口：

java.util.function包含了很多类，用来支持Java的函数式编程，该包中的函数式接口 43 个，最主要的是这四个：

1. 功能性接口：Function<T,R>
2. 断言性接口：Predicate
3. 供给性接口：Supplier
4. 消费性接口：Consumer

函数式接口	参数类型	返回类型	用途
Function	T	R	对类型T参数操作，返回R类型参数，包含方法 R apply（T t）
Predicate	T	boolean	断言型接口，对类型T进行条件筛选操作，返回boolean，包含方法 boolean test（T t）
Supplier	无	T	返回T类型参数，方法是T get()
Consumer	T	void	对类型T参数操作，无返回结果，包含方法 void accept(T t)

2.1 函数式接口Function

Function中没有具体的操作，具体的操作需要我们去为它指定，apply具体返回的结果取决于传入的lambda表达式。
源码查看：

// T 是传入参数
// R 是返回参数
@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    /**
     *  先做传入的Function类型的参数的apply操作，再做当前这个接口的apply操作
     *  V表示这个Function类型的参数的传入参数类型，也就是本接口的T类型
     * @param before
     * @param <V>
     * @return
     */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }


    /**
     *  先做本接口的apply操作，再做传入的Function类型的参数的apply操作
     * @param after
     * @param <V>
     * @return
     */
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    /**
     * 静态方法表示，这个传入的泛型参数T的本身
     * @param <T>
     * @return
     */
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

测试方法

    public String strHandle(String str, Function<String,String> fun){
        return fun.apply(str);
    }

    //功能性接口
    @Test
    public void testFunction(){

        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));

        String newStr=strHandle("\t\t\t woshi nide ",(str)->str.trim());
        System.out.println("功能性接口:"+ newStr);
    }

//输出结果
//    F1:36
//    F1:36
//    F2:26
//    F2:26
//    功能性接口:woshi nide

2.2 断言接口Predicate

Predicate适合在工具类和条件筛选的条件下使用,减少if…else的使用,并且使用灵活
源码查看：

@FunctionalInterface
public interface Predicate<T> {

    /**
     * 该方法是接受一个传入类型,返回一个布尔值.此方法应用于判断
     * @param t
     * @return
     */
    boolean test(T t);

    /**
     *  该些方法接收的是一个Predicate类型参数,返回的也是一个Predicate类型.
     *  and方法用于两个判断是否都成立,与关系型运算符"&&"相似
     * @param other
     * @return
     */
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    /**
     *  该方法没有传入参数,返回一个Predicate类型.此方法用于对判断进行取反.与关系型云算法"!"相似
     * @return
     */
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    /**
     *  or方法则用于两个判断是否有一个成立.与关系型运算符"||"相似
     * @param other
     * @return
     */
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    /**
     *  该方法接收一个Object对象,返回一个Predicate类型.此方法用于判断第一个test的方法与第二个test方法相同(equal)
     * @param targetRef
     * @param <T>
     * @return
     */
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

编写一个工具类示例：

package com._520xuzai.lambda.util;

import java.util.function.Predicate;

public class PredicateUtil {

    public static boolean judgeString(String str, Predicate<String> p){
        if(null == str){
            return false;
        }
        return p.test(str);
    }

    public static boolean judgeNoString(String str, Predicate<String> p){
        if(null == str){
            return false;
        }
        return p.negate().test(str);
    }

    public static boolean judgeAndDoubleString(String str, Predicate<String> p1, Predicate<String> p2){
        if(null == str){
            return false;
        }
        return p1.and(p2).test(str);
    }

    public static boolean judgeOrDoubleString(String str, Predicate<String> p1, Predicate<String> p2){
        if(null == str){
            return false;
        }
        return p1.or(p2).test(str);
    }
}

测试：

 //断言型接口
    @Test
    public void testPredicate(){

        String testString = "abcde";
        // 判断字符串长度是否大于4
        System.out.println(PredicateUtil.judgeString(testString, p->p.length()>4));
        // 判断字符串长度是否大于4再取反
        System.out.println(PredicateUtil.judgeNoString(testString,p->p.length()>4));
        // 判断字符串长度是否大于4并且小于8
        System.out.println(PredicateUtil.judgeAndDoubleString(testString,p->p.length()>4,p->p.length()<8));
        // 判断字符串长度是否小于4并且大于8
        System.out.println(PredicateUtil.judgeOrDoubleString(testString,p->p.length()<4,p->p.length()>8));
        // 判断当前方法是否是"test"方法.
        System.out.println(Predicate.isEqual("test").test("test"));
        System.out.println(Predicate.isEqual("test").test("test1"));
    }
    
//    输出结果
//    true 
//    false 
//    true 
//    false 
//    true 
//    false

2.3消费型接口Consumer

源码查看：

	@FunctionalInterface
    public interface Consumer<T> {

        void accept(T t);

        /**
         * 先做本接口的accept操作，
         * 然后在做传入的Consumer类型的参数的accept操作
         * @param after
         * @return
         */
        default Consumer<T> andThen(Consumer<? super T> after) {
            Objects.requireNonNull(after);
            return (T t) -> { accept(t); after.accept(t); };
        }
    }

简单示例：

    //消费性接口
    @Test
    public void testConsumer(){
        happy(10000,(m)-> System.out.println("这次消费了"+m+"元"));

        JDKBuiltInFunctionTest consumerTest = new JDKBuiltInFunctionTest();

        Consumer<Integer> consumer = i->System.out.println(i);
        IntConsumer intConsumer = i-> System.out.println(i);

        consumerTest.test(consumer);//面向对象式的对象传递
        consumerTest.test(intConsumer::accept);//函数时方式，传递行为--等价于下面
        consumerTest.test(i -> System.out.println(i));
    }

    public void test(Consumer<Integer> consumer){
        consumer.accept(100);
    }
    public void happy(double money, Consumer<Double> con){
        con.accept(money);
    }

2.4 供给型接口Supplier

源码查看

@FunctionalInterface
public interface Supplier<T> {

    /**
     * 这个接口，只是为我们提供了一个创建好的对象
     * @return
     */
    T get();
}

示例

   //供给性接口
    @Test
    public void testSupplier(){
        Supplier<String> supplier = String::new;
        System.out.println(supplier.get());//""
        Supplier<Map> supplierEmp = HashMap::new;
        Map map = supplierEmp.get();
        map.put("name","名字");
        System.out.println(map.get("name"));//名字
    }
 

3、其他相关接口及其描述：

序号	接口 & 描述
1	BiConsumer<T,U> 代表了一个接受两个输入参数的操作，并且不返回任何结果
2	BiFunction<T,U,R> 代表了一个接受两个输入参数的方法，并且返回一个结果
3	BinaryOperator<T> 代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果
4	BiPredicate<T,U> 代表了一个两个参数的boolean值方法
5	BooleanSupplier 代表了boolean值结果的提供方
6	Consumer<T> 代表了接受一个输入参数并且无返回的操作
7	DoubleBinaryOperator 代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。
8	DoubleConsumer 代表一个接受double值参数的操作，并且不返回结果。
9	DoubleFunction<R> 代表接受一个double值参数的方法，并且返回结果
10	DoublePredicate 代表一个拥有double值参数的boolean值方法
11	DoubleSupplier 代表一个double值结构的提供方
12	DoubleToIntFunction 接受一个double类型输入，返回一个int类型结果。
13	DoubleToLongFunction 接受一个double类型输入，返回一个long类型结果
14	DoubleUnaryOperator 接受一个参数同为类型double,返回值类型也为double 。
15	Function<T,R> 接受一个输入参数，返回一个结果。
16	IntBinaryOperator 接受两个参数同为类型int,返回值类型也为int 。
17	IntConsumer 接受一个int类型的输入参数，无返回值 。
18	IntFunction<R> 接受一个int类型输入参数，返回一个结果 。
19	IntPredicate 接受一个int输入参数，返回一个布尔值的结果。
20	IntSupplier 无参数，返回一个int类型结果。
21	IntToDoubleFunction 接受一个int类型输入，返回一个double类型结果 。
22	IntToLongFunction 接受一个int类型输入，返回一个long类型结果。
23	IntUnaryOperator 接受一个参数同为类型int,返回值类型也为int 。
24	LongBinaryOperator 接受两个参数同为类型long,返回值类型也为long。
25	LongConsumer 接受一个long类型的输入参数，无返回值。
26	LongFunction<R> 接受一个long类型输入参数，返回一个结果。
27	LongPredicate R接受一个long输入参数，返回一个布尔值类型结果。
28	LongSupplier 无参数，返回一个结果long类型的值。
29	LongToDoubleFunction 接受一个long类型输入，返回一个double类型结果。
30	LongToIntFunction 接受一个long类型输入，返回一个int类型结果。
31	LongUnaryOperator 接受一个参数同为类型long,返回值类型也为long。
32	ObjDoubleConsumer<T> 接受一个object类型和一个double类型的输入参数，无返回值。
33	ObjIntConsumer<T> 接受一个object类型和一个int类型的输入参数，无返回值。
34	ObjLongConsumer<T> 接受一个object类型和一个long类型的输入参数，无返回值。
35	Predicate<T> 接受一个输入参数，返回一个布尔值结果。
36	Supplier<T> 无参数，返回一个结果。
37	ToDoubleBiFunction<T,U> 接受两个输入参数，返回一个double类型结果
38	ToDoubleFunction<T> 接受一个输入参数，返回一个double类型结果
39	ToIntBiFunction<T,U> 接受两个输入参数，返回一个int类型结果。
40	ToIntFunction<T> 接受一个输入参数，返回一个int类型结果。
41	ToLongBiFunction<T,U> 接受两个输入参数，返回一个long类型结果。
42	ToLongFunction<T> 接受一个输入参数，返回一个long类型结果。
43	UnaryOperator<T> 接受一个参数为类型T,返回值类型也为T。