Java学习与复习笔记--常用函数接口（1）

函数式接口的概念:有且仅有一个抽象方法的接口

“语法糖”：指使用更加方便但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这边是“语法糖”。

函数式接口的格式：

修饰符 interface 接口名称{

            public abstract 返回值类型 方法名称（可选参数信息）;//其他非抽象方法内容

}

函数式接口：

/*
*    函数式接口：有且只有一个抽象方法的接口，称之为函数式接口
*    当然接口中可以包含其他的方法（默认，静态，私有）
*    @Override注解
*    检查方法是否为重写的方法
*    是：编译成功
*    否：编译失败
*    @FunctionalInterface注解
*    作用：检查接口是否是函数式接口
*    是：编译成功
*    否：编译失败（接口中没有抽象方法，抽象方法的个数多于1个）
* */
@FunctionalInterface
public interface MyFunctionalInterface {
    //定义一个抽象方法
    public abstract void method();
}

接口的实现类：

public class MyFunctionalInterfaceImpl implements MyFunctionalInterface{
    @Override
    public void method() {
        System.out.println("实现类，重写接口中的抽象方法");
    }
}

函数式接口的使用：

/*
* 函数式接口的使用：一般可以作为方法的参数和返回值类型
* */
public class Demo {
    //定义一个方法，参数使用函数式接口MyFunctionalInterface
    public static void show(MyFunctionalInterface myInter){
        myInter.method();
    }

    public static void main(String[] args) {
        //调用show方法，方法的参数是一个接口，所以可以传递接口的实现类对象
        show(new MyFunctionalInterfaceImpl());
        //调用show方法，方法的参数是一个接口，所以我们可以传递接口的匿名内部类
        show(new MyFunctionalInterface() {
            @Override
            public void method() {
                System.out.println("使用匿名内部类重写接口中的抽象方法");
            }
        });
        //调用show方法，方法额参数是一个函数式接口，所以我们可以使用Lambda表达式
        show(()->{
            System.out.println("使用Lambda表达式重写接口中的抽象方法");
        });
        //简化Lambda表达式
        show(()-> System.out.println("使用简化后的Lambda表达式重写接口中的抽象方法"));
    }
}

Lambda的延迟执行：有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以作为解决方案，提升性能。

性能浪费的日志案例：

/*
* 日志案例：
* 发现以下代码存在一些性能浪费的问题
* 调用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 msg1="Hello";
        String msg2="World";
        String msg3="Java";
        //调用showLog方法，传递日志级别和日志信息
        showLog(2,msg1+msg2+msg3);
    }
}

使用Lambda优化日志案例：

函数式接口：

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

案例本体：

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

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

使用Lambda作为参数和返回值：

/*
* 例如java.lang.Runnable接口就是一个函数式接口
* 假设有一个startThread方法使用该接口作为参数，那么就可以使用Lambda进行传参
* 这种情况其实和Thread类的构造方法参数为Runnable没有本质区别。
* */
public class Demo03Runnable {
    //定义一个方法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()+"-->"+"线程启动了"));
    }
}

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

/*
* 如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式。
* 当需要通过一个方法来获取一个java.util.Comparator接口类型的对象作为排序器时，就可以调该方法获取。
* */
public class Demo04Comparator {
    //定义一个方法，方法的返回值类型使用函数式接口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={"aaaa","b","cccccc","ddddddddd"};
        //输出排序前的数组
        System.out.println(Arrays.toString(arr));//[aaaa, b, cccccc, ddddddddd]
        //调用Arrays中的sort方法，对字符串数组进行排序
        Arrays.sort(arr,getComparator());
        //输出排序后的数组
        System.out.println(Arrays.toString(arr));//[ddddddddd, cccccc, aaaa, b]
    }
}

常用的函数式接口_Supplier接口：

/*
* 常用的函数式接口
*  java.util.function.Supplier<T>接口仅包含一个无参的方法： T get().用来获取一个泛型参数指定类型的对象数据。
*  Supplier<T>接口被称之为生产型接口，指定接口的泛型是什么类型，那么接口中的get()方法就会生产什么类型的数据
*/
public class Demo01Supplier {
    //定义一个方法，方法的参数传递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 s1=getString(()-> "胡歌");
        System.out.println(s1);
    }
}
/*
* 练习：求数组元素最大值
*      使用Supplier接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值。
*      提示：接口的泛型请使用java.lang.Integer类
*      */
public class Demo02Supplier {
    //定义一个方法，用于获取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,88,99,33,-30};
        //调用getMax方法，方法的参数Supplier是一个函数式接口，所以可以传递Lambda表达式
        int maxValue=getMax(()->{
           //获取数组的最大值，并返回
           //定义一个变量，把数组中的第一个元素赋值给变量，记录数组中元素的最大值
           int max=arr[0];
           //遍历数组，获取数组中的其他元素
            for (int i : arr) {
                //使用其它的元素和最大值进行比较
                if(i>max){
                    //如果i大于max，则替换max作为最大值
                    max=i;
                }
            }
            //返回最大值
            return max;
        });
        System.out.println("数组中元素的最大值是："+maxValue);
    }
}