JAVA学习笔记21 函数式接口

函数式接口概述

函数式接口:有且仅有一个抽象方法的接口(但可以有别的default方法)
Java中的函数式编程体现就是Lambda表达式，所以函数式接[就是可以适用于Lambda使用的接口
只有确保接口中有且仅有一个抽象方法， Java中的ambda才能顺利地进行推导

栗子1：
MyInterface接口：

package FunctionInterface.Demo01;
@FunctionalInterface
public interface MyInterface {
    void show();
}

@FunctionalInterface注解，用于限制这个接口里只有一个方法，这样他就一定可以作为一个函数接口了（必须有且只有一个方法），如果没有这个注解也是可以的，但是为了确保他只有一个方法，还是用比较好，因为如果不满足的话会报错。

MyInterfaceDemo：

package FunctionInterface.Demo01;

import javax.sound.midi.Soundbank;

public class MyInterfaceDemo {
    public static void main(String[] args) {
        MyInterface my=()-> System.out.println("函数式接口");
        my.show();

    }
}

函数式接口，可以理解为 （）为某个接口，由于前面是MyInterface所以这里（）指的就是MyInterface接口，没有参数，需要执行的内容为System.out.println(“函数式接口”),也就是将MyInterface接口中唯一的那个方法(也就是show())，重写为了System.out.println(“函数式接口”)然后再调用这个重写的方法my.show()。

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

package FunctionInterface.Demo01.RunnableDemo;

public class RunnableDemo {
    public static void main(String[] args) {
        //调用startThread方法

        //匿名内部类
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了");
            }
        });

        //函数式接口
        startThread(()->{
            System.out.println(Thread.currentThread().getName()+"线程启动了");
        });
    }

    private static void startThread(Runnable r){
//        Thread t=new Thread(r);
//        t.start();
        new Thread(r).start();

    }
}

其实就是之前我们学lambda表达式的一个Demo一个意思，只是这里强调的是把lambda作为参数，也就是（）作为接口以及参数。

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

package FunctionInterface.Demo01.ReturnDemo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ReturnDemo {
    public static void main(String[] args) {
        //构造使用场景
        ArrayList<String> arrayList=new ArrayList<String>();

        arrayList.add("cccc");
        arrayList.add("aa");
        arrayList.add("b");
        arrayList.add("ddd");

        Collections.sort(arrayList,getComparetor());
        System.out.println(arrayList);
    }
    //这是一个方法，用于得到一个Comparator，这个Comparator是定义一种排序方式的，这里定义的排序方式为哪个String的length长哪个就在后面
    private static Comparator<String> getComparetor(){
        //使用匿名内部类
        return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        };
    }
}

这里先是用的匿名内部类的方式获取这个comparato r比较器，我们可以使用lambda表达式代替这个匿名内部类，以获取比较器comparator。

package FunctionInterface.Demo01.ReturnDemo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ReturnDemo {
    public static void main(String[] args) {
        //构造使用场景
        ArrayList<String> arrayList=new ArrayList<String>();

        arrayList.add("cccc");
        arrayList.add("aa");
        arrayList.add("b");
        arrayList.add("ddd");

        Collections.sort(arrayList,getComparetor());
        System.out.println(arrayList);
    }
    //这是一个方法，用于得到一个Comparator，这个Comparator是定义一种排序方式的，这里定义的排序方式为哪个String的length长哪个就在后面
    private static Comparator<String> getComparetor(){
        return (String s1,String s2)->{
            return s1.length()-s2.length();
        };
        //Comparator是一个函数式接口（有函数式接口的注解，只有一个方法）
        //这个方法要求返回值必须是Comparator，所以这里使用lambda表达式肯定是重写并执行了Comparator中唯一的那个方法
        //String s1,String s2为接口需要的参数，{return s1.length()-s2.length();}为重写并执行的内容。
    }
}

Comparator是一个函数式接口（有函数式接口的注解，只有一个方法）。
这个方法要求返回值必须是Comparator，所以这里使用lambda表达式肯定是重写并执行了Comparator中唯一的那个方法。
String s1,String s2为接口需要的参数，{return s1.length()-s2.length();}为重写并执行的内容。

常用函数式接口之Supplier

package FunctionInterface.Demo01.SupplierDemo;

import java.util.function.Supplier;

public class SuppllierDemo {
    public static void main(String[] args) {
        //匿名内部类
        String s1=getString(new Supplier<String>() {
            @Override
            public String get() {
                return "zbz";
            }
        });
        System.out.println(s1);
        
        //Supplier是一个函数式接口，所以可以使用lambda方式
        String s=getString(()->{
            return "林青霞";
        });
        System.out.println(s);
    }
    
    //定义一个方法，返回一个字符串数据
    private static String getString(Supplier<String> sup){
        return sup.get();
    }
}

package FunctionInterface.Demo01.SupplierDemo;

import java.util.function.Supplier;

public class SupplierMaxDemo {
    public static void main(String[] args) {
        int[] arr = {12, 33, 44, 11};

        int maxValue = getMax(() -> {
            int max = arr[0];

            for (int i = 0; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }

            return max;
        });

        System.out.println(maxValue);
    }

    //返回一个int数组的最大值
    private static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}