java中showinfo报错

函数式接口：有且只有一个抽象方法的接口，称之为函数式接口
当然接口中可以包含其他的方法(默认，静态，私有)
@FunctionalInterface
作用：可以检测接口是否是一个函数式接口
是：编译成功
否：编译失败(接口中没有抽象方法或抽象方法的个数多余一个)

@FunctionalInterface
public interface MyFunctionalInterface {
    public abstract void method();
}

函数式接口的使用：一般作为方法的参数和返回值类型

public class Demo {
    public static void show(MyFunctionalInterface myInter){
        myInter.method();
    }

    public static void main(String[] args) {
        show(new MyFunctionalInterfaceImpl());

        show(new MyFunctionalInterface() {
            @Override
            public void method() {
                System.out.println("使用匿名内部类重写接口中的抽象方法");
            }
        });

        show(()->
                System.out.println("使用Lambda表达式重写接口中的抽象方法"));
    }
}

日志案例
发现以下代码存在的一些性能浪费的问题
调用showLog方法,传递的第二个参数是一个拼接后的字符串
先把字符串拼接好,然后在调用showLog方法
showLog方法中如果传递的日志等级不是1级
那么就不会是如此拼接后的字符串
所以感觉字符串就白拼接了,存在了浪费

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

    public static void main(String[] args) {
        String msg1 = "Hello";
        String msg2 = "World";
        String msg3 = "Java";

        showLog(1,msg1+msg2+msg3);

    }
}

使用Lambda优化日志案例
Lambda的特点：延迟加载
Lambda的使用前提，必须存在函数式接口

使用Lambda表达式作为参数传递,仅仅是把参数传递到showL og方法中
只有满足条件,日志的等级是1级
才会调用接口MessageBuilder中的方法builderMessage
才会进行字符串的拼接
如果条件不满足，日志的等级不是1级
那么MessageBuilder接口中的方法builderMessage也不会执行
所以拼接字符串的代码也不会执行
所以不会存在性能的浪费

@FunctionalInterface
public interface MessageBuilder {
    public abstract String  logBuilder();
}


public class Demo02Lambda {
    public static void showLog(int level,MessageBuilder mb){
        if (level == 1) {
            System.out.println(mb.logBuilder());
        }
    }

    public static void main(String[] args) {
        String msg1 = "Hello";
        String msg2 = "World";
        String msg3 = "Java";

        showLog(1,()->{
            System.out.println("不满足条件不执行");
            return msg1+msg2+msg3;
        });
    }
}

例如java.lang.Runnable接口就是一个函数式接口
假设有一个startThread方法使用该接口作为参数，那么就可以使用Lambda进行传参
这种情况其实和Thread类的构造方法参数为Runnable没有本质区别

public class Demo01Runnable {
    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()+"线程启动了");
            }
        });

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

如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式
当需要通过一个方法来获取一个java.util.Comparator接口类型的对象作为排序器时，就可以调用该方法

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

public class Demo02Comparator {
    public static Comparator<String> getComparator(){
       /* return new Comparator<String>() {
            @Override
            public int compare(String s, String t1) {
                return t1.length()-s.length();
            }
        };*/

        return (s,t1)-> t1.length()-s.length();
    }

    public static void main(String[] args) {
        String[] arr = {"aaa","bbb","dddd"};

        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr,getComparator());
        System.out.println(Arrays.toString(arr));

    }
}