Java基础---B站学习---函数式编程

Java基础—B站学习—函数式编程

1.Lambda的延迟执行

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

2.性能日志浪费案例

2.1通过案例发现问题

2.2优化日志案例

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

public class Demo02Lambda {
    // 定义一个显示日志的方法，方法的参数传递日志的等级和messageBuilder
    public static void showLog(int level,MessageBuilder mb){
        // 对日志的等级进行判断，如果是1调用MessageBuilder接口中的builderMeaasage方法
        if (level == 1){
            System.out.println(mb.builderMeaasage());
        }
    }

    public static void main(String[] args) {
        String msgA = "Hello";
        String msgB = "World";
        String msgC = "Java";

        showLog(1,()->{
            // 返回一个拼接好的字符串
            return msgA+msgB+msgC;
        });
    }
}

3.使用Lambda作为参数和返回值—例子

使用Lambda作为参数的案例

public class Demo01Runnable {
    // 定义一个方法startRunnable，方法的参数使用函数式接口Runnable
    public static void startRunnable(Runnable run){
        new Thread(run).start();
    }

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

        // 调用startRunnable方法,方法的参数是个函数式接口，那么可以传递Lambda表达式
        startRunnable(()->{
            System.out.println(Thread.currentThread().getName()+"---->"+"线程启动了");
        });

        // 优化Lambda表达式
        startRunnable(()->System.out.println(Thread.currentThread().getName()+"---->"+"线程启动了"));

    }
}

使用Lambda作为返回值的案例

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();
    }

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

    }

}

补充：

接口中明明有两个抽象方法，int compare(T o1, T o2);和boolean equals(Object obj);为何还是函数式接口？

1. 因为：如果接口声明了一个覆盖java.lang.Object的全局方法之一的抽象方法，那么它不会计入接口的抽象方法数量中，因为接口的任何实现都将具有java.lang.Object或其他地方的实现。