java函数式接口

1.什么是函数式接口

函数式接口

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

实现

public class DemoImpl implements DemoStart{
    public static void main(String[] args) {

    }

    @Override
    public void method() {
        System.out.println("实现了函数式接口");
    }
}

使用

public class FunctionsImpl {
    //函数式接口的使用一般可以作为方法的参数或返回值类型
    private static void method(DemoStart s) {
        s.method();
    }
    public static void main(String[] args) {
    //1.调用show方法，方法的参数是一个接口所以可以床底接口的实现类对象
        method(new DemoImpl());
    //2.调用show方法，方法的参数是一个接口，所以我们可以传递接口的匿名内部类
        method(new DemoStart() {
            @Override
            public void method() {
                System.out.println("匿名内部类的形式！！！");
            }
        });
        //3.调用show方法其，方法的参数是一个接口，所以可以用lambda表达式
        method(()->{
             System.out.println("lambda表达式的方法！");
        });
        //3.调用show方法其，方法的参数是一个接口，所以可以用lambda表达式(简化)
        method(()-> System.out.println("lambda表达式(简化)的方法！"));
    }

}
函数式接口作为方法参数
使用lambda表达作为参数减少性能浪费（必须为函数式接口）

package DiaryDemo;

public interface Diary {
    String method();
}

package DiaryDemo;
/*
lambda的特点延迟加载
使用前提必须为函数式接口

使用lambda表达式最为参数传递，仅仅是把参数传递到方法中只有满足条件才会进行字符拼接所以不存在性能浪费
 */

public class Main {
    public static void main(String[] args) {
        String a="i";
        String a1="love";
        String a2="you";
        method(1,a+a1+a2);
        method(2,a+a1+a2);
        method1(1,()->a+a1+a2);
        method1(2,()->a+a1+a2);
    }
    private static void method(int i, String s) {
        if(i==1){
            System.out.println(s);
        }
    }
//    private static void method1(int i, Diary s) {
//        System.out.println("调用了方法2");
//        if(i==1){
//            System.out.println(s.method());
//        }
//    }
    private static void method1(int i, Diary s) {
    if(i==2){
        System.out.println("不满足条件不执行");
    }
}
}

函数式接口作为返回值类型

package DiaryDemo;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
/*
函数式接口作为返回值类型，我们可以返回其匿名内部类
 */
public class CompareDemo {

    private static Comparator<String> getCompare(){
//        return new Comparator<String>(){
//            @Override
//            public int compare(String o,String o1) {
//               return o.length()- o1.length();
//            }
//        };
//        return (String o1,String o2)->{
//            return o1.length()-o2.length();
//        };
        return (o1,o2)->o1.length()-o2.length();
    }
    public static void main(String[] args) {
        String []arr={"adadawsdasd","456456456","adad"};
        Arrays.sort(arr,getCompare());
        for (String s :
                arr) {
            System.out.println(s);
        }
        Arrays.sort(arr, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.length()-o1.length();
            }
        });
        for (String s :
                arr) {
            System.out.println(s);
        }
    }
}