java8四大函数式接口简单了解学习测试

    /**
     * java8 四大函数式接口
     *     Consumer<T>消费型接口                 void accept(T t);
     *     Supplier<T>供给型接口                    T get();
     *     Function<T,R>函数型接口                R apply(T t);
     *     Predicate<T>断言型接口。              boolean test(T t);
     * @param args
     */

一个测试的类People:   String name,String hobby;

 

   
public static void main(String[] args) {
        People p=new People("小刘","音乐");
        consumer(p,t-> System.out.println("我的名字是："+p.getName()+"\t\t我的爱好是"+p.getHobby()));
        consumer(p,t->{
            t.setName("哇哈哈");
            t.setHobby("music");
        });
        System.out.println(p);
    }





     /**
     * //消费型接口，就是你给我数值，我去做什么事
     * @param people
     * @param con
     */
    public static void consumer(People people, Consumer<People>con){
        con.accept(people);
    }

 输出结果是：

从结果可以看出来：和预期的一样，和java8常用的遍历类似；

从list的源码可以看出来forEach是个消费型函数 ；

值得注意的是这个泛型的写法。一般我们会遇到两种：

• <? extends T> 是指   “上界通配符（Upper Bounds Wildcards）” 可以get
• <? super T> 是指  “下界通配符（Lower Bounds Wildcards）”     可以add 相反则不行。
• Java编译器会阻止对声明类型为List<? extend T>的集合的add操作；会阻止对声明类型为List<? super T>的集合的get操作。

 

 

 

 

总的内容和测试结果为：

    /**
     * java8 四大函数式接口
     * Consumer<T>消费型接口                 void accept(T t);
     * Supplier<T>供给型接口                    T get();
     * Function<T,R>函数型接口                R apply(T t);
     * Predicate<T>断言型接口。              boolean test(T t);
     *
     * @param args
     */
    public static void main(String[] args) {
        People p = new People("小刘", "音乐");

        /**
         * 消费型接口的测试
         */
        System.out.println("--------------消费型接口的测试-----------------");
        consumer(p, t -> System.out.println("我的名字是：" + p.getName() + "\t\t我的爱好是" + p.getHobby()));
        consumer(p, t -> {
            t.setName("哇哈哈");
            t.setHobby("music");
        });
        System.out.println(p);
        /**
         * 供给型接口的测试
         */
        System.out.println("------------------供给型接口的测试---------------------");
        People supplier = supplier(p, () -> {
            return p;
        });
        System.out.println(supplier);


        /**
         * 函数型接口  --
         */
        System.out.println("--------------函数型接口--------------------");
        String introuduce = intrFun(p, t -> {
            return t;
        });
        System.out.println(introuduce);

        /**
         * 断言型接口
         */
        System.out.println("-------------------------断言型接口-------------------------");
        predicate(p, t -> {
            System.out.println(t);
            return t != null ? true : false;
        });
    }


    /**
     * 有参数，无返回值
     * //消费型接口，就是你给我数值，我去做什么事
     *
     * @param people
     * @param con
     */
    public static void consumer(People people, Consumer<People> con) {
        con.accept(people);
    }

    /**
     * 供给型接口的测试   无参数，有返回值
     *
     * @param people
     * @param p
     * @return
     */
    public static People supplier(People people, Supplier<People> p) {
        return p.get();
    }

    /**
     * 函数型接口      有参数，可以有返回值
     *
     * @param people
     * @param fn
     * @return
     */
    public static String intrFun(People people, Function<People, People> fn) {
        People people2 = fn.apply(people);
        return "我的名字是：" + people2.getName() + "\t\t我的爱好是:" + people2.getHobby();
    }


    /**
     * 断言型接口   有参数，返回值boolean
     *
     * @return
     */
    public static People predicate(People people, Predicate<People> pre) {
        boolean b = pre.test(people);
        return b ? people : null;
    }

 

：简单学习和了解一下java8的函数式接口;一些集合和stream会经常用到。

  再需要学习Java 8新特性：lambda表达式;