常用函数接口

函数式接口——————有且只有一个抽象方法的接口，称之为函数式接口。
当然接口中可以包含其他的方法（默认，静态，私有）。
@FunctionalInterface注解
作用—————————可以检测接口是否是一个函数式接口
是————编译成功
否————编译失败（接口中没有抽象方法，抽象方法的个数多余一个）
函数式接口的使用———一般可以作为方法的参数和返回值类型

性能浪费的日志案例

package cn.lrf.lambdaDemo;

/*日志案例
 * 发现以下代码存在的一些性能浪费的问题
 * 调用showLog方法，传递的第二个参数是一个拼接后的字符串
 * 先把字符串拼接好，然后再调用showLog方法
 * showLog方法中如果传递的日志等级不是1级
 * 那么就不会是如此拼接后的字符串
 * 所以感觉字符串就白拼接了，存在浪费*/
public class Demo01Logger {
    //定义一个根据日志的级别，显示日志信息的方法
    public static void showLog(int level, String message) {
        //对日志等级进行判断，如果是1级别，那么输出日志信息
        if (level == 1) {
            System.out.println(message);
        }

    }

    public static void main(String[] args) {
//定义三个日志信息
        String mgs1 = "Hello";
        String mgs2 = "World";
        String mgs3 = "Java";
        //调用showLog方法，传递日志级别和日志信息
        showLog(1,mgs1+mgs2+mgs3);
    }
}

使用Lambda优化日志案例

package cn.lrf.lambdaDemo;

/*使用Lambda优化日志案例
 * Lambda的特点————————延迟加载
 * Lambda的使用前提，必须存在函数式接口*/
public class Demo02Lambda {
    //显示日志信息的方法，方法的参数传递日志的等级和MessageBuilder接口
    public static void showLog(int level, MessageBuilder mb) {
        //对日志等级进行判断，如果是1级别，则调用MessageBuilder接口中的builderMessage方法
        if (level == 1) {
            System.out.println(mb.builderMessage());
        }

    }

    public static void main(String[] args) {
//定义三个日志信息
        String mgs1 = "Hello";
        String mgs2 = "World";
        String mgs3 = "Java";
        //调用showLog方法，参数MessageBuilder是一个函数式接口，所以可以传递Lambda表达式
        showLog(2, () -> {
            //返回一个拼接好的字符串
            return mgs1 + mgs2 + mgs3;
        });
        /*使用Lambda表达式作为参数传递，仅仅是把参数传递到showLog方法中
         * 只有满足条件，日志的等级是1级
         * 才会调用MessageBuilder接口中的方法builderMessage
         * 才会进行字符串的拼接
         * 如果条件不满足，日志等级不是1级
         * 那么MessageBuilder接口中的方法builderMessage也不会执行
         * 所以拼接字符串的代码也不会执行
         * 所以不会存在性能的浪费*/
    }
}

package cn.lrf.lambdaDemo;

@FunctionalInterface
public interface MessageBuilder {
    //定义一个拼接消息的抽象方法，返回被拼接的消息
    public abstract String builderMessage();
}

函数式接口作为方法的参数案例

package cn.lrf.hanShu;

/*假如java.lang.Runnable接口就是一个函数式接口，
 * 假设有一个startThread方法使用该接口作为参数，那么就可以使用Lambda参数进行传参。
 * 这种情况其实和Thread类的构造方法参数为Runnable没有本质区别*/
public class Demo01Runnable {
    //一个startThread方法，方法参数使用函数式接口Runnable
    public static void startThread(Runnable run){
        //开启多线程
        new Thread(run).start();
    }

    public static void main(String[] args) {
        //调用startThread方法，方法的参数是一个接口，那么我们可以传递这个接口的匿名内部类对象
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"-->线程启动了");
            }
        });
        //调用startThread方法，方法的参数是一个函数式接口，所以可以传递Lambda表达式
        startThread(()->{
            System.out.println(Thread.currentThread().getName()+"-->线程启动了");
        });
        //优化Lambda表达式
        startThread(()->System.out.println(Thread.currentThread().getName()+"-->线程启动了")
        );
    }
}

函数式接口作为方法的返回值

package cn.lrf.hanShu;

import java.util.Arrays;
import java.util.Comparator;

/*如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式
 * 当需要通过一个方法来获取一个java.util.Comparator接口类型的对象作为排序器时，就可以调用该方法获取*/
public class Demo02Comparator {
    //定义一个方法，方法的返回值类型使用函数式接口Comparator
    public static Comparator<String> getComparator() {
       /* //方法的返回值类型是一个接口，那么我们可以返回这个接口的匿名内部类
        return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //按照字符串的降序排序
                return o2.length() - o1.length();
            }
        };*/
        //方法的返回值类型是一个函数式接口，所以我们可以返回一个Lambda表达式
        /*return (String o1, String o2) -> {
            //按照字符串的降序排序
            return o2.length() - o1.length();

        };*/
        //继续优化Lambda表达式
        return (o1, o2) -> o2.length() - o1.length();
    }

    public static void main(String[] args) {
//创建一个字符串数组
        String[]arr={"aaa","b","cccccccccccc","dddddddddddd"};
        //输出排序前的数组
        System.out.println(Arrays.toString(arr));//[aaa, b, cccccccccccc, dddddddddddd]
        //调用Arrays.sort方法，对数组进行排序
        Arrays.sort(arr,getComparator());
        //输出排序后的数组
        System.out.println(Arrays.toString(arr));//[cccccccccccc, dddddddddddd, aaa, b]
    }
}

常用的函数式接口———Supplier接口

package cn.lrf.hanShu;

import java.util.function.Supplier;

/*常用的函数式接口
 * java.util.function.Supplier<T>接口仅包含一个无参的方法：T get()。用来获取一个泛型参数指定类型的对象数据。
 * Supplier<T>接口被称之为生产型接口，指定接口泛型是什么类型，那么接口中的get方法就会生产什么类型的数据*/
public class Deno01Supplier {
    //定义一个方法，方法的参数床底Supplier<T>接口，泛型执行String,get方法就会放回一个String
    public static String getString(Supplier<String> sup) {
        return sup.get();
    }

    public static void main(String[] args) {
        //调用getString方法，方法的参数Supplier是一个函数式接口，所以可以传递Lambda表达式
        String s = getString(() -> {

            //生产一个字符串并返回
            return "胡歌";

        });
        System.out.println(s);
        //优化Lambda表达式
        String s2 = getString(() -> "胡歌");
        System.out.println(s2);
    }
}

练习————常用的函数式接口Supplier接口

package cn.lrf.hanShu;

import java.util.function.Supplier;

/*练习
 * 求数组元素最大值
 * 使用Supplier接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值。
 * 提示——————接口的泛型请使用java.lang.Integer类*/
public class Demo01Test {
    //定义一个方法，用于获取int类型数组中元素的最大值，方法的参数传递Supplier接口，泛型使用Integer
    public static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }

    public static void main(String[] args) {
        //定义一个int类型的数组，并赋值
        int[] arr = {100, 0, -50, 888, 99, 33, -33};
        //调用getMax方法，方法的参数Supplier是一个函数式接口，所以传递Lambda表达式
        int maxVaule=getMax(() -> {
            //获取数组的最大值并返回
            //定义一个变量，把数组中的第一个元素赋值给该变量，记录数组中元素的最大值
            int max = arr[0];
            //遍历数组，获取数组中的其他元素
            for (int i : arr) {
                //使用其他元素和最大值比较
                if (i > max) {
                    //如果i大于max，则替换max作为最大值
                    max = i;
                }
            }
            return max;
        });
        System.out.println("数组中元素的最大值时："+maxVaule);
    }
}

常用的函数式接口——Consumer接口

package cn.lrf.hanShu;

import java.util.function.Consumer;

/*java.util.function.Comsumer<T>接口则正好于Supplier接口相反，
 * 它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。
 * Consumer接口中包含抽象方法void accept（T t）,意为消费一个指定泛型的数据。
 * 至于具体怎么消费（使用），需要自定义（输出，计算...）*/
public class Demo01Comsumer {
    /*
     * 定义一个方法
     * 方法的参数传递一个字符串的姓名
     * 方法的参数传递一个Consumer接口消费字符串的姓名*/
    public static void method(String name, Consumer<String> con) {
        con.accept(name);
    }

    public static void main(String[] args) {
//调用method方法，传递字符串姓名，方法的另一个参数是Consumer，是一个函数式接口，所以可以传递一个Lambda表达式
        method("赵丽颖", (String name) -> {
            //对传递的字符串进行消费

            //消费方式————直接输出字符串
            //  System.out.println(name);
            //消费方式————把字符串进行反转输出
            String reName=new StringBuffer(name).reverse().toString();
            System.out.println(reName);
        });
    }
}

常用的函数式接口——Consumer接口

package cn.lrf.hanShu;
/*Consumer接口的默认方法andThen
 * 作用————需要两个Consumer接口，可以把两个Consumer接口组合到一起，在对数据进行消费
 * 例如
 * Consumer<String> con1
 * Consumer<String> con2
 * String s="hello*
 * con1.accpet(s)
 * con2.accpet(s)
 * 连接两个Consumer接口 在进行消费
 * con1.andThen(con2).accpet(s);谁写在前面谁先消费
 */

import java.util.function.Consumer;

public class Demo02AndThen {
    //定义一个方法，方法的参数传递一个字符串和两个Consumer接口，Comsumer接口的泛型使用字符串
    public static void method(String s, Consumer<String> con1, Consumer<String> con2) {
        // con1.accept(s);
        //con2.accept(s);
        //使用andThen方法，把两个consumer接口连接到一起，在消费数据
        con1.andThen(con2).accept(s);//con1连接con2，先执行con1消费数据，在执行con2消费数据
    }

    public static void main(String[] args) {
        //调用method方法，传递一个字符串两个Lambda表达式
        method("Hello",
                (t) -> {
                    //消费方式————把字符串转换为大写输出
                    System.out.println(t.toUpperCase());
                },
                (t) -> {
                    //消费方式————把字符串转换为小写输出
                    System.out.println(t.toLowerCase());
                });
    }
}

练习————常用的函数式接口Consumer接口

package cn.lrf.hanShu;

import java.util.function.Consumer;

/*练习
 * 字符串数组当中存有多条信息，请按照格式”姓名：XX。性别：XX“的格式将信息打印出来。
 * 要求将打印性别的动作作为第二个Consumer接口的labmbda实例，
 * 将两个Consumer接口按照顺序”拼接“到一起*/
public class Demo03 {
    //定义一个方法，参数传递String类型的数组和两个Consumer接口，泛型使用String
    public static void pintInfo(String[] arr, Consumer<String> con1, Consumer<String> con2) {
        //遍历字符串数组
        for (String message : arr) {
            //使用andThen方法连接两个Consumer接口，消费字符串
            con1.andThen(con2).accept(message);
        }
    }

    public static void main(String[] args) {
        //定义一个字符串类型的数组
        String[] arr = {"迪丽热巴,女", "古力娜扎,女", "马儿扎哈,男"};
        //调用pringtInfo方法，传递一个字符串数组，和两个Lambda表达式
        pintInfo(arr, (message) -> {
                    //消费方式——————对message进行切割，获取姓名，按照指定格式输出
                    String name = message.split(",")[0];
                    System.out.print("姓名：" + name);
                }, 
                (message) -> {
                    //消费方式——————对message进行切割，获取年龄，按照指定格式输出
                    String age = message.split(",")[1];
                    System.out.println("。年龄：" + age+"。");
                });
    }
}

常用的函数式接口——Predicate接口

package cn.lrf.hanShu;

import java.util.function.Predicate;

/*java.util.fuction.Predicater<T>接口

作用————对某种数据类型的数据进行判断，结果返回一个boolean值。
Predicate接口中包含一个抽象方法
boolean test (T t)————用来对指定数据类型进行判断的方法。
结果
符合条件，返回true
不符合条件，返回false*/
public class Demo01Predicate {
    /*定义一个方法
     * 参数传递一个String类型的字符串
     * 传递一个Predicate接口，泛型使用String
     * 使用Predicate中的方法test对字符串进行判断，并把判断的结果返回*/
    public static boolean checkString(String s, Predicate<String> pre) {
        return pre.test(s);

    }

    public static void main(String[] args) {

        //定义一个字符串
        String s = "abcdef";
//调用checkString方法对字符串进行校验，参数传递字符串和Lambda表达式
        boolean b=checkString(s,(String str)->{
            //对参数传递的字符串进行判断，判断字符串的长度是否大于5，并把判断的结果返回
            return str.length()>5;
        });
        System.out.println(b);
    }
}

逻辑表达式——————可以连接多个判断的条件
&&————与运算符，有false则false
||—————或运算符，有true则true
！—————非（取反）运算符，非假则真，非真则假
需求————判断一个字符串，有两个判断的条件
1.判断字符串的长度是否大于5
2.判断字符串中是否包含a

• 两个条件必须同时满足，我们就可以使用&&运算符连接两个条件。

Predicate接口中有一个方法and,表示并且关系，也可以用于连接两个判断条件

default Predicate<T>and(Predicate<? super T>other){
return(t)->this.test(t)&&other.test(t);
}

方法内部的两个判断条件，也是使用&&运算符连接起来的 。

需求————判断一个字符串，有两个判断的条件
1.判断字符串的长度是否大于5
2.判断字符串中是否包含a

• 满足一个条件即可，我们就可以使用||运算符连接两个条件。

Predicate接口中有一个方法or,表示或者关系，也可以用于连接两个判断条件

default Predicate<T>and(Predicate<? super T>other){
return(t)->this.test(t)||other.test(t);
}

方法内部的两个判断条件，也是使用||运算符连接起来的 。
需求————判断一个字符串长度是否大于5
1.如果字符串的长度大于5，那么返回false。
2.如果字符串的长度不大于5，那么返回true。

• 我们就可以使用取反符号！对判断的结果进行取反。

Predicate接口中有一个方法negate,也表示取反

default Predicate<T>negate(){
return(t)->！test(t);
}

常用的函数式接口——Function接口

java.util.function.Function<V,R>接口根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。

• Function接口中最主要的抽象方法——R applay(T t),根据类型T的参数获取类型R的结果。

使用的场景例如————将String类型转换为Integer类型。

• Function接口中的默认方法andThen——用来进行组合操作
  需求
  把String类型的“123”，转换为Integer类型，把转换后的结果加10。
  把增加之后的Integer类型的数据，转换为String类型。