Java——函数式接口、Supplier接口、Consumer接口、Predicate接口、Function接口

一、函数式接口概述

• 函数式接口：有且仅有一个抽象方法的接口
• 函数式接口是Lambda表达式的前提
• 用@FunctionalInterface进行注解

@FunctionalInterface
public interface MyInterface {
   
    void show();
}

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

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

1、例子

① 需求

定义一个类(RunnableDemo)，在类中提供两个方法

• startThread(Runnable r)，方法参数Runnable是一个函数式接口
• 主方法，调用startThread方法

② 代码实现

public class RunnableDemo {
   
    public static void main(String[] args) {
   
        //匿名内部类实现
        startThread(new Runnable() {
   
            @Override
            public void run() {
   
                System.out.println(Thread.currentThread().getName() + "线程启动了");
            }
        });

        //Lambda表达式
        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表达式作为参数传递

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

1、例子

① 需求

定义一个类(ComparatorDemo)，在类中提供两个方法

• Comparator< String > getComparator()，方法返回值Comparator是一个函数式接口
• 主方法，调用getComparator方法

② 代码实现

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

public class ComparatorDemo {
   
    public static void main(String[] args) {
   
        ArrayList<String> array = new ArrayList<String>();
        array.add("ccccc");
        array.add("bbb");
        array.add("d");
        System.out.println("排序前：" + array);
        System.out.println("-------------");

        Collections.sort(array);
        System.out.println("自然排序后：" + array);
        System.out.println("-------------");

        Collections.sort(array, getComparator());
        System.out.println("排序后：" + array);
        System.out.println("-------------");
    }

    private static Comparator<String> getComparator() {
   
        //实现1：匿名内部类
        /*Comparator<String> comp = new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        };
        return comp;*/

        //实现2：匿名内部类的简化
       /* return new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        };*/

        //实现3：Lambda表达式
       /* return (String s1,String s2)->{
            return s1.length()-s2.length();
        };*/

        //实现4：Lambda表达式简化
        return (s1, s2) -> s1.length() - s2.length();
    }
}

如果方法的返回值是一个函数式接口，可以使用Lambda表达式作为结果返回

四、常用的函数式接口

• Supplier
• Consumer
• Predicate
• Function

五、Supplier接口

1、Supplier< T >包含一个无参的方法：

• T get()：获得结果。该方法不需要参