java中的函数式接口

是什么？？

有且只有一个抽象方法的接口

场景：

适用于函数式编程场景（使用lambda表达式编程）的接口，函数式接口可以适用于lambda使用的接口。

只有确保接口中有且只有一个抽象方法，java中的lambda才能顺利推到

格式

/**
 * 函数式接口：有且之哟一个抽象方法的接口
 *          接口中可以包含其他的方法，包括默认方法，静态方法，私有方法
 *
 * @FunctionalInterface
 * 作用：可以检测接口是否是一个函数式接口
 *      是：编译成功
 *      否：编译失败（接口中没有抽象方法，抽象方法的个数大于1）
 */

@FunctionalInterface
public interface MyInterface {
    //定义一个抽象方法
    public abstract void method();

//    void  method2();
}

函数式接口的使用：

/**
 * 函数式接口的使用：可以作为方法的参数和返回值类型
 */

Lambda作为参数

例如:

public class Demo {
    public static  void show(MyInterface myInterface){
        myInterface.method();
    }

    public static void main(String[] args) {
        //调用show方法，方法的参数是一个接口，所以可以传递接口的实现类对象
        show(new MyInterfaceImp());

        //调用show方法，方法的参数是一个接口，所以可以传递接口的匿名内部类
        show(new MyInterface() {
            @Override
            public void method() {
                System.out.println("使用匿名内部类重写接口的抽象方法");
            }
        });

        //调用show方法，方法的参数是一个函数式接口，所以，我们可以使用lambda表达式
        show(()->{
            System.out.println("使用lambda表达式重写接口中的抽象方法");
        });

        //简化lambda表达式
        show(()-> System.out.println("简化lambda表达式"));
    }

注意：使用匿名内部类回生成.class文件，但是lambda表达式不会，减少JVM的加载

结果：

函数式编程

Lambda的延迟执行减少性能浪费:

例子:

/**
 * 日志案例
 * 发现下面代码存在性能浪费
 *
 * 调用showLog方法的过程：
 *      先将msg1 msg2 msg3拼接好之后，调用showLog方法。
 *      但是如果level不等于1，那就不执行了。
 *      所以拼接字符串的过程就浪费了
 */

public class Demo01Logger {
    public static void showLog(int level,String msg){
        if (level == 1){
            System.out.println(msg);
        }
    }

    public static void main(String[] args) {
        String msg1 = "AAA";
        String msg2 = "BBB";
        String msg3 = "CCC";

        showLog(1,msg1+msg2+msg3);
    }
}

利用lambda表达式优化：

1先定义一个函数式接口

@FunctionalInterface
public interface MessageBuilder {
    //定义拼接消息的抽象方法，返回拼接完成的消息
    public abstract String builderMsg();
}

/**
 * lambda优化
 *
 * lambda延迟加载：
 * lambda使用前提：必须存在函数式接口：
 */
public class Demo02Logger {
    //显示日志方法，
    public static void showLog(int level,MessageBuilder messageBuilder){
        if (level == 1){
            System.out.println(messageBuilder.builderMsg());
        }
    }

    public static void main(String[] args) {
        String msg1 = "AAA";
        String msg2 = "BBB";
        String msg3 = "CCC";
        //调用showLog方法，参数MessageBuilder式一个函数式接口，可以传递Lambda表达式
        showLog(1,()->{
            //返回一个拼接好的字符串
            System.out.println("有没有拼接");
            return msg1+msg2+msg3;
        });
    }
}

可以通过改变日志级别，看看输出存不存在"有没有拼接"

/**
 *使用lambda表达式作为参数传递，仅仅式吧参数传递到showLog方法中
 * 只有满足条件，日志的等级式1
 *      才会调用接口MessageBuilder中的方法builderMessage
 *      进行字符串拼接
 * 如果不满足
 *      接口MessageBuilder中的方法builderMessage不会执行
 *      不会导致性能浪费
 */

Lambda作为参数和返回值

public class Demo03Runable {
    //定义一个方法startThread 方法参数使用函数式接口Runnable
    public static void startThread(Runnable runnable){
        new Thread(runnable).start();
    }

    public static void main(String[] args) {
        //匿名内部类实现
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了");
            }
        });

        //因为Runnable接口是一个函数式接口，里面只有一个抽象方法run方法，可以使用lambda表达式
        startThread(()->{
            System.out.println(Thread.currentThread().getName()+"lambda线程启动了");
        });

        startThread(()->
            System.out.println(Thread.currentThread().getName()+"优化lambda线程启动了"));
        }

}

Lambda作为返回值

public class Demo02Comparator {
    //定义一个方法，方法的返回值位函数式接口Comparator
    public static Comparator<String> getComparator(){
        //方法返回值式一个接口，返回接口的匿名内部类
        return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //安装字符串降序排序
                return o1.length() - o2.length();

            }
        };

    }

    public static Comparator<String> getComparator2() {
        //方法返回值式一个函数式接口，返回接口的lambda表达式
        return (String o1, String o2)->{
            return o1.length() - o2.length();
        };
    }

    //优化表达式
    public static Comparator<String> getComparator3() {
        //方法返回值式一个函数式接口，返回接口的lambda表达式
        return ( o1,  o2)-> o1.length() - o2.length();
    }

    public static void main(String[] args) {
        String[] arr = {"AAAAAAA","BBBB","CCCCCCC"};
        System.out.println(Arrays.toString(arr));
        //对数组进行拍寻
        Arrays.sort(arr,getComparator());
        System.out.println(Arrays.toString(arr));
    }

}

常用的函数式接口：

Supplier接口：

java.util.function.Supplier<T> 接口包含一个无参方法：T get()

作用：用来获取一个泛型参数指定类型的对象数据。

对应的lambda表达式需要提供一个符合泛型类型的对象数据

/**
 * 常用函数式接口
 *  java.util.function.Supplier<T> 接口被称为生产型接口。
 * Supplier指定什么类型的泛型就返回什么类型的数据
 */

public class Demo01Supplier {
    //方法参数传递Supplier接口，泛型String，get返回一个String
    public static String getString(Supplier<String> supplier){
        return supplier.get();
    }

    public static void main(String[] args) {
        //调用getString方法。使用lambda表达大师
        String s = getString(()->{
            return "生成字符串";
        });

        //优化表达式
        String s1 = getString(()->"优化生成字符串");

        System.out.println(s);
        System.out.println(s1);
    }
}

结果：

生成字符串
优化生成字符串

简单练习

/**
 * 求数组最大值
 *      使用Supplier接口作为参数类型，通过lambda表达式求出int数组的最大值
 */

答案：

public class Demo02Test {
    //获取数组元素的最大值，参数位supplier接口，泛型Integer
    public static Integer getMax(Supplier<Integer> supplier){
        return supplier.get();
    }

    public static void main(String[] args) {
        //定义数组
        int[] arrint = {111,222,444,333};
        int maxinarr =getMax(()->{
           int max = arrint[0];
            for (int i : arrint) {
                if(i>max){
                    max = i;
                }
            }
            return max;
        });

        System.out.println(maxinarr);
    }

}

Consumer

/**
 * java.util.function.Consumer<T> 消费一个数据，数据类型又泛型决定
 * 消费型接口，使用型接口
 * accept
 *
 */

public class Demo03Consumer {
    public static void method(String name, Consumer<String> consumer){
        consumer.accept(name);
    }

    public static void main(String[] args) {
        //因为accept有参数，所以lambda表达式需要加入参数。
        method("quanzhiqiang",(String name)->{
            System.out.println(name);

            String reName = new StringBuffer(name).reverse().toString();
            System.out.println(reName);
        });

    }
}

结果:

quanzhiqiang
gnaiqihznauq

Consumer中的默认方法 andThen

/**
 * Consumer接口默认方法andThen
 * 作用：需要两个Consumer接口，可以把两个Consumer接口组合到一起，
 * 在对数据进行消费
 *
 * Consumer<String> co1
 * Consumer<String> co2
 * String str1 = "done"
 * co1.accept(str1)
 * co2.accept(str1)
 * 可以简洁点：
 * co1.andThen(con2).accept(s)
 *
 * 连接两个Consumer接口，再进行消费，谁写前面谁先消费
 */

public class Demo4Consumer {
    public static void method(String str , Consumer<String> co1,Consumer<String> co2){
        co1.accept(str);
        co2.accept(str);
    }

    public static void method1(String str , Consumer<String> co1,Consumer<String> co2){
      co1.andThen(co2).accept(str);//执行co1再执行co2，比上面的要简洁一些
    }

    public static void main(String[] args) {
        method1("quan",
                (t)->{//lambda表达式参数的类型，可以省略
                    System.out.println(t.toUpperCase());
                },
                (t)->{
                    System.out.println(t.toLowerCase());
                });

    }

}
/**
 * QUAN
 * quan
 * 结果
 */

练习：

/**
 * 字符串数组中存在多条信息，按照格式姓名：xx 性别：Xx格式打印出来
 * 答应名名字位第一个Consumer接口的lambda实例
 * 打印性别式第二个
 * 然后拼接起来
 */

public class Demo5Consmer {

    public static void pringinfo(String[] arr , Consumer<String> c1,Consumer<String> c2){
        for (String s : arr) {
           c1.andThen(c2).accept(s);
        }
    }
    public static void main(String[] args) {
        String[] arr = {"AA,N","BB,M","CC,N"};
        pringinfo(arr,
                ( msg)->{
//            对字符串进行分割，取出姓名
            String name = msg.split(",")[0];
                    System.out.print("姓名："+name);
                },
                (msg)->{
//            对字符串进行分割，取出性别
            String sex = msg.split(",")[1];
                    System.out.println("性别："+sex);
                });

    }
}

Predicate接口

/**
 * java.util.function.Predicate<T>接口
 * 作用：对某种数据类型的数据进行判断，结果返回一个boolean值
 *     接口有一个抽象方法：
 *     boolean test（T t）:用来对指定数据类型数据进行判断
 *
 *
 */

public class PredicateTest {
    //定义方法，参数传递一个字符串，Predicate接口
    public static boolean checkString(String s, Predicate<String> pred){
        return  pred.test(s);
    }

    public static void main(String[] args) {
        String  s ="ABCD";
        System.out.println(checkString(s,(ss)->{
            if (ss.length()>5){
                return true;
            }else {
                return false;
            }
        })
        );
    }
}

接口中的默认方法，and  or negate：

/**
 * 判断一个字符串长度大于5 且字符串是否包含a
 */
public class PredicateT {
    public static boolean checkString(String s, Predicate<String> p1, Predicate<String> p2){
//        return  p1.test(s) && p2.test(s);
        return p1.and(p2).test(s);//等价于上面
//        return p1.or(p2).test(s);//或
//        return p1.negate().test(s)//negate非
    }

    public static void main(String[] args) {
        String s = "anbced";
        boolean re =checkString(s,
                (ss)->{
            return ss.length()>5;
                },
                (ss)->{
            return ss.contains("a");
                });
        System.out.println(re);
    }
}

练习：

/**
 * 将数组里面的名字等于4位的且是女生的用arraylist保存起来
 */
public class PredicateTest2 {
    private static void xuanze(String[] arr, Predicate<String> pre1, Predicate<String> pre2){
        List<String> stringList =new ArrayList<>();
        for (String s : arr) {
            if(pre1.and(pre2).test(s)){
                stringList.add(s);
            }
        }
        System.out.println(stringList);
    }

    public static void main(String[] args) {
        String[] arr = {"1111,N","222,M","44444","N"};
        xuanze(arr,
                (s)->{
                 return  s.split(",")[0].length()==4;
                },
                (s)->{
                return s.split(",")[1].equals("N");
                });
    }
}

Function接口

/**
 * java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据
 *                          前者位前置条件，后者位后置条件
 *  接口里面的抽象方法： R apply<T t>,根据类型T参数获取类型R参数的结果。
 *          了例如：String类型转换位Integer类型
 */

public class FunctionDemo {
    public static void exchange(String s, Function<String,Integer> function){
        Integer i = function.apply(s);
//        int i1 = function.apply(s);自动拆箱，将Integer类型自动拆成Int类型
        System.out.println(i);
    }

    public static void main(String[] args) {
        String si = "123";
        exchange(si,(ss)->{
           return Integer.parseInt(ss);
        });
//优化
//        exchange(si,(ss)-> Integer.parseInt(ss)
//        );
    }
}

默认方法andThen

/**
 * Function接口的默认方法andThen：用来进行组合操作
 * 需求：String类型的123 转换为Integer类型，把转换结果加10
 * 把增加之后的Integer类型的数据转换为String类型
 *
 */
public class FunctionDemo2_andThen {

    private static void change(String s,Function<String,Integer> f1,Function<Integer,String> f2){
       String ss =  f1.andThen(f2).apply(s);
        System.out.println(ss);
    }

    public static void main(String[] args) {
        String s = "123";
        change(s,
                (s1)->{
            //把字符串转整数
                    return Integer.parseInt(s1)+10;
                },
                (i)->{
            return i+"";
                });
    }
}