函数式编程接口

函数式接口

概念
函数式接口在java指的是：有且仅有一个抽象方法的接口就称为函数式接口。
函数式接口，使用于函数式编程，在java当中的函数式编程体现在Lambda，所以函数式接口就是用来服务Lambda表达式。只有确保接口当中有且仅有一个抽象方法，java中的lambda才能顺利的进行推导。
备注：语法糖是指使用更加便利方便，但是原理不变的代码语法。就比如便利集合的时使用for-each语法，其实底层使用的是迭代器，这便是语法糖。
格式
只有确保接口当中有且仅有一个抽象方法即可：

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

示例如下：

public interface FunctionInterfaceOne{
	public abstract void show01();
	public default void show02(){
	}
	//.............
	//void show03();有且仅有一个抽象方法，才被称为函数式接口
}

@Functionallnterface注解

与@Overried注解作用类型，java8中专门为函数式接口引入一个新注解@functionalInterface,该注解主要定义在接口上。一旦在接口上使用该注解，编译期将会强制检查接口是不是一个函数式接口，该接口中是不是有且仅有一个抽象方法，如果不是，编译报错。

@FunctionalInterface
public interface FunctionInterfaceOne {
    //定义一个抽象方法
    void method();

    //void show();//有且仅有一个抽象方法
    public default void show(){

    }
}

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

函数式编程

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

Lambda的延迟加载

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

 public static void main(String[] args) {
        // 定义一些日志信息
        String message1 = "执行mysqld.exe操作";
        String message2 = "执行java.exe操作";
        String message3 = "执行tomcat.exe操作";

        // 调用showLog方法，参数是一个函数式接口--BuildLogMessage接口，所以可以使用Lambda表达式
       /* showLog(2, () -> {
            // 返回一个拼接好的字符串
            return message1 + message2 + message3;
        });*/

        // 简化Lambda表达式
        /*
               使用Lambda表达式作为参数传递，
               只有满足条件，日志的等级小于等于3
                     才会调用此接口BuildLogMessage当中的方法buildLogMessage
                     才会进行字符串的拼接动作
               如果条件不满足，日志的等级大于3
                      那么BuildLogMessage接口当中的方法buildLogMessage也不会执行
                      所以拼接字符串的动作也不会执行
                      所以不会存在性能上的浪费。
         */
        showLog(4, () -> {
            System.out.println("前面的日志等级大于3，此处不执行！");
           return message1 + message2 + message3;
        });
  }

备注：实际上使用内部类也可以达到这样的效果，只是将代码操作延迟到另外一个对象当中通过调用方法来完成。
后面的代码的执行取决于前面的条件的判断结果。

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

在java当中，Lambda表达式是作为匿名内部类的替代品，如果一个方法的参数是一个函数式接口类型，那么可以使用Lambda表达式进行替代
java.lang.Runnable接口就是一个函数式接口
代码如下：

public class Demo01Lambda{
	//定义一个方法，开启线程的方法
	public static void startThread(Runnable r){
		new Thread(r).start();
	}
	public static void main(String[] args){
		startThread(()->{
			System.out.println("开启一个新线程，线程任务被提升了!");
		});
		//优化Lambda
		startThread(()->System.out.println("开启一个新线程，线程任务被提升了!"));
	}
}

如果一个方法的返回值类型是一个函数式接口，那么我们可以直接使用一个Lambda表达式。
java.util.Comperator接口是一个函数式接口
代码如下：

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

常用的函数式接口

JDK提供了大量的常用函数式接口，丰富Lambda表达式的使用场景。他们主要在java.util.function包中被提供。
Supplier接口
java.util.function.Supplier <T> 接口，该接口有且仅有一个无参的方法:T get()。用来获取一个泛型参数指定类型的对象数据。由于该接口是一个函数式接口，所以我们可以使用Lambda表达式来操作它。
Supplier<T>接口被称之为生产型接口，指定接口的泛型是什么类型，那么接口中的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 new String("你好java");
        });
        System.out.println(str);*/
       //求一个int类型的数组中的最值
        int[] arr = {10,20,5,8,3,30};
        int maxNum = getNum(() -> {
            //求出数组的最大值
            int max = arr[0];
            for (int i : arr) {
                //判断
                if (max < i) {
                    max = i;
                }
            }
            return max;
        });
        System.out.println(maxNum);
    }

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 s = name.toUpperCase();
            System.out.println(new StringBuffer(s).reverse().toString());
        } );
    }

默认 的方法：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("Java-中国最棒-都是业界大佬", name1->{
            //消费规则
            //截取传入的字符串
            String substring = name1.substring(0, 6);
            System.out.println(substring);
        },name2-> {
            //定义消费规则 分成字符串数组进行展示
            String[] strs = name2.split("-");
            System.out.println(Arrays.toString(strs));//{"Java","中国最棒","都是业界大佬"}
        });
    }

通过查看源码得知：endThen方法不允许传入一个null对象否则就会抛出一个控制针异常。
要想把两次消费的动作连接起来，需要传入两个consumer接口，通过endThen方法实现一步一步执行消费动作。
例如一个小例子：

/*定义一个字符串数组，存储一个人的信息："张三,20,郑州市"，，存储5个人的信息
    使用Consumer接口按照指定的格式进行一个打印输出：姓名：张三;年龄:20;地址：郑州市
    要求将打印姓名的动作作为第一个consumer接口的规则
    将打印年龄的动作作为第二个consumer接口的规则
    将打印地址的动作作为第三个consumer接口的规则*/
    //定义一个方法  方法的参数为一个Strng字符串数组    三个Consumer接口
    public static void consumer(String str[], Consumer<String> con1, Consumer<String> con2, Consumer<String> con3) {
        for (String s : str) {
            con1.andThen(con2).andThen(con3).accept(s);
            System.out.println();
        }
    }

    public static void main(String[] args) {
        String[] str = new String[5];
        str[0] = "张三,20,北京";
        str[1] = "李四,20,上海";
        str[2] = "王五,20,深圳";
        str[3] = "赵六,20,广州";
        str[4] = "田七,20,苏州";
        consumer(str, name->
                        System.out.print("姓名:" + name.split(",")[0] + ";"),
                age->
                        System.out.print("年龄:" + age.split(",")[1] + ";"),
                address->
                        System.out.print("地址:" + address.split(",")[2]));
    }