Java 常用函数式接口案例之Consumer接口

案例1

import java.util.function.Consumer;

/**
 * java.util.function.ConsumerT:该接口的作用与Supplier接口作用相反，将创建的参数消费（使用）掉。
 * Consumer接口中包含了唯一一个抽象方法void accept(T t);消费一个指定泛型的数据
 *
 * defau<  ConsumerT andThen(Consumer? super T after) {
 *     Objects.requireNonNull(after);
 *     return (T t) - { accept(t); after.accept(t); };
 * }
 * andThen();方法将两个Consumer接口组合在一起，对数据进行消费。
 *
 */
public class ConsumerDemo {
    /*
        定义一个方法，方法的泛型指定为String，传递的参数为字符串类型的数据，调用accept方法使用该数据
     */
    public static void dealData(String str, ConsumerString con){
        con.accept(str);
    }

    public static void main(String[] args) {

        //使用Lambda表达式实现函数式编程
        *//*dealData("ABC",(String str)-{
            System.out.println(str);
        });*//*

        //简化Lambda表达式
       dealData("ABC",str-System.out.println(str));
    }
}

案例2

import java.util.function.Consumer;

/**
 * java.util.function.ConsumerT:该接口的作用与Supplier接口作用相反，将创建的参数消费（使用）掉。
 * Consumer接口中包含了唯一一个抽象方法void accept(T t);消费一个指定泛型的数据
 *
 * defau<  ConsumerT andThen(Consumer? super T after) {
 *     Objects.requireNonNull(after);
 *     return (T t) - { accept(t); after.accept(t); };
 * }
 * andThen();方法将两个Consumer接口组合在一起，对数据进行消费。
 *
 */
public class ConsumerDemo {

    /*
        定义一个方法，方法的泛型指定为String，传递的参数为字符串类型的数据和两个Consumer接口，调用accept方法使用该数据
     */
    public static void method(String str, ConsumerString con1, ConsumerString con2){
        /*con1.accept(str);
        con2.accept(str);*/
        //使用endThen方法，将两个Consumer接口连接在一块
        con1.andThen(con2).accept(str);//先执行con1使用数据，在执行con2使用数据
    }

    public static void main(String[] args) {
        //传递的参数为一个字符串、两个Lambda表达式
        method("Hello",
                (str)-{
                    System.out.println(str.toUpperCase());
                 },
                (str)-{
                    System.out.println(str.len >h());
                });
    }
}

案例3：

import java.util.function.Consumer;

/**
 * java.util.function.ConsumerT:该接口的作用与Supplier接口作用相反，将创建的参数消费（使用）掉。
 * Consumer接口中包含了唯一一个抽象方法void accept(T t);消费一个指定泛型的数据
 *
 * defau<  ConsumerT andThen(Consumer? super T after) {
 *     Objects.requireNonNull(after);
 *     return (T t) - { accept(t); after.accept(t); };
 * }
 * andThen();方法将两个Consumer接口组合在一起，对数据进行消费。
 *
 */
public class ConsumerDemo {
 
    public static void main(String[] args) {
        String[] arr = {"AA,男","BB,女","CC,男"};

        //使用匿名内部类实现
       /* printInfo(arr, new ConsumerString() {
            @Override
            public void accept(String s) {
                System.out.print("  姓名："+s.split(",")[0]+"  ");
            }
        }, new ConsumerString() {
            @Override
            public void accept(String s) {
                System.out.print("性别："+s.split(",")[1]);
            }
        });*/

        //使用Lambda表达式实现
        printInfo(arr, s - System.out.print("姓名："+s.split(",")[0])
                     , s - System.out.println("  性别："+s.split(",")[1]));
    }

    //定义一个方法，传递一个数组和两个Consumer接口
    public static void printInfo(String[] arrs, ConsumerString con1, ConsumerString con2){
        for (String arr : arrs) {
            con1.andThen(con2).accept(arr);
        }
    }

}