Java函数式接口

函数式接口

概念

• 函数式接口在Java中指的是：有且仅有一个抽象方法的接口就称为函数式接口。
• 函数式接口，适用于函数式编程，在Java中的函数式编程体现在Lambda，所以函数式接口就是用来服务Lambda表达式。只有确保接口当中在有且仅有一个抽象方法，Java中的Lambda才能顺利进行推导。

备注：“语法糖”是指使用更加便利方便，但是原理不变的代码语法。就比如遍历集合时使用foreach语法，其实底层使用的是迭代器，这便是“语法糖”。

格式
只要确保接口当中有且仅有一个抽象方法即可：

修饰符 interface InterfaceName{
	//只能定义一个抽象方法
	pubic abstract 返回值类型 方法名称(参数列表);
	//还可以定义其它非抽象方法
}

示例：

/*
    函数式接口：有且仅有一个抽象方法,一般作为方法的参数和返回值使用
    接口当中还可以包含其它方法（默认、静态、私有。。。）

 */
public interface Demo01 {
    void method();
}
//实现类
public class Demo01Impl implements Demo01{
    @Override
    public void method() {
        System.out.println("这是实现类重写的方法");
    }
    public static void show(Demo01 d){
        d.method();
    }
    
    public static void main(String[] args) {
        show(new Demo01Impl());
        show(new Demo01() {
            @Override
            public void method() {
                System.out.println("这是匿名内部类重写的方法");
            }
        });
        //Lambda
        show(()->{
            System.out.println("这是lambda表达式的写法");
        });
        //简化lambda
        show(()-> System.out.println("简化lambda"));
    }
}

@FunctionalInterface注解

Java 8中专门为函数式接口引入的一个新注解，该注解要定义在接口上。一旦在接口上定义该注释，编译器会强制检查该接口是否是不是一个函数式接口，该接口是否只有一个抽象方法，如果不是，编译出错

@FunctionalInterface
public interface interName{
	void method();
	//void show();
}

自定义函数式接口的用途

• 对于自定义的函数式接口，一般用于方法的参数和返回值上。

函数式编程

能够在兼顾Java的面向对象特性的基础上，通过Lambda表达式与后面的方法引用，为开发者打开函数式编程的大门。

Lambda的延迟加载

有些场景的代码运行执行后，结果不一定会被使用到，从而造成性能的浪费。而lambda表达式是延迟执行的，正好可以解决此问题，提升性能。

使用Lambda作为方法的参数和返回值

  在Java当中，Lambda表达式是作为匿名内部类的替代品，如果一个方法的参数是一个函数式接口，那么可以使用Lambda表达式进行替代

public class Demo{
	public static void startThread(Runnable r){
		new Thread(r).start();
	}
public static void main(String[] args){
	startThread(()->{
		System.out.println("开启一个新线程，线程任务被执行了！");
	});
}
}

如果一个方法的返回值是一个函数式接口，那么我们可以直接使用一个lambda表达式。

代码如下：

public class Demo2{
	//定义一个方法，方法的返回值类型是一个函数式接口类型Comparator
	public static Comparator<String> createComparator(){
		//返回值就是一个函数式接口
		return new Comparator(){
			@Override
			public int compare(String o1,String o2){
				//自定义比较的规则  升序/降序
			}
		}
		//使用Lambda
		return(o1,o2) -> o1.length() - o2.length();
	}
	public static void main(String[] args){
		String[] strs={"aaa","a","bajdhj","dajdd"};
		Arrays.sort(strs,createComparator());
		System.out.println(Arrays.toString(strs));
	}
}

常用的函数式接口

 JDK提供了大量常用的函数式接口，丰富lambda表达式的使用场景，他们主要在java.util.functiion包中被提供。

Supplier接口

• 该接口有且仅有一个无参的方法：T get()。用来获取一个泛型参数指定类型的对象数据。由于该接口是一个函数式接口，所以可以使用lambda表达式来操作它。
• Supplier接口被称之为生产型接口，指定接口的泛型是什么类型，那么接口中的get()方法就会生产什么类型的数据。

代码如下：

 // 定义一个方法，方法的参数传递一个Supplier<T>接口，泛型指定String，get方法就会返回一个String
    public static String getString(Supplier<String> sup) {
        return sup.get();
    }
    // 定义一个方法，方法的参数传递一个Supplier<T>接口，泛型我指定为Integer，get方法就会返回一个int
    public static int getNum(Supplier<Integer> sup) {
        return sup.get();
    }
    public static void main(String[] args) {
        // 调用getString方法，方法的参数传递Supplier<T>是一个函数式接口，那么我们就可以使用Lambda
       /*  String str = getString(() -> {
            // 生产一个字符串并返回
            return "你好Java";
        });
        System.out.println(str);*/
        
        // 求一个int类型的数组中的最值
        int[] arr = {10,20,5,8,3,50};
        int maxNum = getNum(() -> {
            // 求出数组的最大值
            int max = arr[0];
            for (int i : arr) {
                // 判断
                if (max < i) {
                    max = i;
                }
            }
            return max;
        });
        // 输出最大值
        System.out.println(maxNum);// 50
    }

Consumer 接口

java.util.function.Consumer<T>接口刚好和Supplier接口相反，它不是用来生产一个数据，而是消费一个数据。

accept方法

意思就是消费一个指定泛型的数据。

代码如下：

   // 定义一个方法，方法的参数传递一个Consumer<String>接口,传递一个字符串变量
    public static void consumer(String str, Consumer<String> con) {
        // 使用消费型接口对象，消费传递的字符串值。
         con.accept(str);
    }

    public static void main(String[] args) {
        // 来调用消费方法consumer,Consumer<String>接口是一个函数式接口类型，所以可以使用Lambda表达式
        consumer("abcdefg", name -> {
            // 把里面的abcdefg字符串改为大写输出 消费的规则自定义
            String str = name.toUpperCase();
            String s = new StringBuffer(str).reverse().toString();
            System.out.println(s);// GFEDCBA
        });
    }  

默认的方法：andThen

如果一个方法的参数和返回值全都是Consumer类型，那么就可以实现这样的效果：消费数据的时候，首先做一个消费的操作，在做一个消费的操作，实现组合。可以通过Consumer接口当中的默认方法:andThen来实现。

代码如下：

// 定义一个方法，方法的参数传递一个字符串和两个Consumer接口，Consumer接口的泛型指定为字符串
    public static void consumers(String str, Consumer<String> con1,Consumer<String> con2) {
       /* con1.accept(str);
        con2.accept(str);*/
        // andThen 连续消费  default Consumer<String> andThen
        // 先执行左边的Consumer--con1的动作，andThen--->再次执行Consumer--con2动作
        con1.andThen(con2).accept(str);
        // 规则 con1连接con2 ，先执行con1消费数据，在执行con2消费数据
    }

    public static void main(String[] args) {
        // 由于consumers方法的参数Consumer接口是一个函数式接口，可以使用Lambda表达式
        consumers("Java31-中国最棒-都是业界大佬", (name1)->{
              // 消费规则
              // 截取传入的字符串
            String sub = name1.substring(0, 6);
            System.out.println(sub);

        }, (name2) -> {
            // 定义消费的规则 分成字符串数组展示
            String[] strs = name2.split("-");

            System.out.println(Arrays.toString(strs));// {“Java31","中国最棒","都是业界大佬"}
        });
    }

通过查看源码得知：andThen方法不允许传入一个null对象否则就会抛出空指针异常。

要想把两次消费的动作连接起来，需要传入两个Consumer接口，通过andThen方法实现一步一步执行消费动作。

练习：

​ 定义一个字符串数组，存储每一个人的信息如：“张三，20，郑州市”,存储5个人的信息

​ 使用Consumer接口，按照指定的格式进行打印输出：姓名:张三;年龄:20;地址:郑州市

​ 要求将打印姓名的动作作为第一个Consumer接口的规则

​ 将打印年龄的动作作为第二个Consumer接口的规则

​ 将打印地址的动作作为第三个Consumer接口的规则。

​ 最终将三个Consumer接口按照规定的顺序拼接输出出来。

​ 代码如下：

  // 规则
    public static void consumers(String[] arr, Consumer<String> con1, Consumer<String> con2, Consumer<String> con3) {
        // 操作arr数组当中的每一个元素
        for (String str : arr) {
            con1.andThen(con2).andThen(con3).accept(str);// 定义了消费的先后的顺序
        }
    }
    public static void main(String[] args) {
        // 定义一个字符串数组
        String[] arr = {"李四,20,南阳市", "张三,20,郑州市", "小孙,20,开封市", "小丽,20,信阳市", "小赵,20,洛阳市"};
        // 调用consumers方法，由于Consumer接口是一个函数式接口，所以可以使用Lambda
        consumers(arr, one -> System.out.print("姓名:" + one.split(",")[0] + ";"),
                two -> System.out.print("年龄:" + two.split(",")[1] + ";"),
                three -> System.out.println("地址:" + three.split(",")[2]));

    }