java函数式接口Consumer接口类中andThen方法详解

java函数式接口Consumer接口类中andThen方法详解

代码案例

package it_04;

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {
        
        // Lambda表达式
        operatorString("林青霞",(String s) -> {
            System.out.println(s);
        });
        
        // 简化Lambda表达式
        operatorString("林青霞",s -> System.out.println(s));

        // 方法引用
        operatorString("林青霞",System.out::println);
        
        // 反转字符串
        operatorString("林青霞",s -> System.out.println(new StringBuilder(s).reverse().toString()));

        System.out.println("*********************");
        operatorString(
                "林青霞",
                s -> System.out.print(s),
                s -> System.out.print(new StringBuilder(s).reverse().toString())
        );
}

private static void operatorString(String name, Consumer<String> con1, Consumer<String> con2){
        con1.accept(name);
        con2.accept(name);

        con1.andThen(con2).accept(name);
}

private static void operatorString(String name, Consumer<String> con){
        con.accept(name);
    }
}

输出：
林青霞
林青霞
林青霞
霞青林
*********************
林青霞
霞青林
林青霞
霞青林

package it_04;

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {

        // Lambda表达式
//        operatorString("林青霞",(String s) -> {
//            System.out.println(s);
//        });
//
//        // 简化Lambda表达式
//        operatorString("林青霞",s -> System.out.println(s));
//
//        // 方法引用
//        operatorString("林青霞",System.out::println);
//
//        // 反转字符串
//        operatorString("林青霞",s -> System.out.println(new StringBuilder(s).reverse().toString()));

        System.out.println("*********************");
//        operatorString(
//                "林青霞",
//                s -> System.out.println(s),
//                s -> System.out.println(new StringBuilder(s).reverse().toString())
//        );

        operatorString(
                "林青霞",
                s -> {
                    System.out.println(s);
                    System.out.println("con1*****");
                },
                s -> {
                    System.out.println(new StringBuilder(s).reverse().toString());
                    System.out.println("con2*****");
                });
    }

    private static void operatorString(String name, Consumer<String> con1, Consumer<String> con2){
//        con1.accept(name);
//        con2.accept(name);

        con1.andThen(con2).accept(name);
        }
	private static void operatorString(String name, Consumer<String> con){
        con.accept(name);
    }

}

*********************
林青霞
con1*****
霞青林
con2*****

源码

@FunctionalInterface
public interface Consumer<T> {

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

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

andThen方法详解

首先我们来解释这一段代码：
    operatorString(
            "林青霞",
            s -> {
                System.out.print(s);
                System.out.print("con1*****");
            },
            s -> {
                System.out.print(new StringBuilder(s).reverse().toString());
                System.out.print("con2*****");
            });

     自定义的operatorString()方法，该方法设置了三个参数即 String name, Consumer<String> con1, Consumer<String> con2

     我们调用operatorString()方法
     传入三个参数，一个是字符串，另外两个是Lambda表达式
     两个Lambda表达式传入该方法时，会分别重写Consumer类的抽象类方法accept()，并分别创建对象
     即我们会有 Consumer<String> con1接口类和 Consumer<String> con2接口类，如下，它们的accept()都被重写了
     public interface Consumer<String> con1 {
    void accept(T t){
        s -> System.out.println(s);
        System.out.println("con1*****");
        };

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


    public interface Consumer<String> con2 {
    void accept(T t){
        s -> System.out.println(new StringBuilder(s).reverse().toString());
        System.out.println("con2*****");
        };

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

    然后开始执行自定义operatorString类中的 con1.andThen(con2).accept(name); 代码
    其中con1.andThen(con2)，就是相当于将Consumer<String> con2接口类传入con1.andThen()方法中
    在andThen()源码中，发现该方法返回是return (T t) -> { accept(t); after.accept(t); };
    要注意这里：因为是con2接口类传入con1.andThen()方法中，所以上面代码中花括号中的accept(t);
    是调用的con1类中的accept()方法，而after.accept(t); 就相当于是con2.accept(t);
    所以是return (T t) -> { s -> System.out.println(s); con2.accept(t); };
    即 return (T t) -> { s -> System.out.println(s); s -> System.out.println(new StringBuilder(s).reverse().toString();};

    我们返回的是一个Lambda表达式，就相当于返回了一个被重写了抽象方法的Consumer<T>类对象
    即该类对象中，重写了accept()抽象方法，方法体为{ s -> System.out.println(s); s -> System.out.println(new StringBuilder(s).reverse().toString();}
    即con1.andThen(con2).accept(name);，就变为 Consumer<T>.accept(name);
     Consumer<T>调用本身的accept()方法，并传入字符串参数 “林青霞 ”，所以会输出林青霞，霞青林

代码过程

分别重写了con1类和con2类的accept()方法，如下：

public interface Consumer<String> con1 {
        void accept(T t){
            s -> System.out.println(s);
            System.out.println("con1*****");
            };

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


        public interface Consumer<String> con2 {
        void accept(T t){
            s -> System.out.println(new StringBuilder(s).reverse().toString());
            System.out.println("con2*****");
            };

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

		
        执行该代码con1.andThen(con2)时，相当于创建了一个Consumer<T>接口类
        并重写了其中的accept(T t)方法

        public interface Consumer<T> {
        void accept(T t){
            (T t) -> {  s -> System.out.println(s);
                        System.out.println("con1*****");
            s -> System.out.println(new StringBuilder(s).reverse().toString();
            System.out.println("con2*****");
            }
            };

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

		
		最后
        con1.andThen(con2).accept(name);
        Consumer<T>.accept(name)
        林青霞
        con1*****
        霞青林
        con2*****

简单理解

con1.andThen(con2).accept(name);
就是con1类先调用accept(name)对name进行处理，并输出
接下来就是con2类调用accept(name)对name进行处理，并输出