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

绝地灬酷狼 2023-03-12 12:13 2阅读 0赞

### 案例1 ###

import java.util.function.Consumer;
    
    /**
     * java.util.function.Consumer<T>:该接口的作用与Supplier接口作用相反，将创建的参数消费（使用）掉。
     * Consumer接口中包含了唯一一个抽象方法void accept(T t);消费一个指定泛型的数据
     *
     * default Consumer<T> 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, Consumer<String> 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.Consumer<T>:该接口的作用与Supplier接口作用相反，将创建的参数消费（使用）掉。
     * Consumer接口中包含了唯一一个抽象方法void accept(T t);消费一个指定泛型的数据
     *
     * default Consumer<T> 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, Consumer<String> con1, Consumer<String> 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.length());
                    });
        }
    }

### 案例3： ###

import java.util.function.Consumer;
    
    /**
     * java.util.function.Consumer<T>:该接口的作用与Supplier接口作用相反，将创建的参数消费（使用）掉。
     * Consumer接口中包含了唯一一个抽象方法void accept(T t);消费一个指定泛型的数据
     *
     * default Consumer<T> 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 Consumer<String>() {
                @Override
                public void accept(String s) {
                    System.out.print("  姓名："+s.split(",")[0]+"  ");
                }
            }, new Consumer<String>() {
                @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, Consumer<String> con1, Consumer<String> con2){
            for (String arr : arrs) {
                con1.andThen(con2).accept(arr);
            }
        }
    
    }