函数式接口
1、概念、格式
函数式接口在Java中是指只有一个抽象方法的接口，但是接口中还可以有其他方法，比如public、default等，只有确保接口只有一个抽象方法，Lambda才能进行顺利的推导。
格式
@FunctionalInterface// 使用注解来检测该接口是否函数式接口，也就是是否只有一个抽象方法
修饰符 interface 接口名称 {
public abstract 返回值类型 方法名称(参数列表)；
}
函数式接口作为方法的参数：
package cn.zhuobo.day16.aboutFuntionalInterface;
//函数式接口作为一个方法的参数，有三种用法去调用这个方法
public class MyFunctionalInterfaceMain {
public static void main(String[] args) {
// 1、创建一个实现类对象传递给show方法，该实现类里重写了抽象方法
show(new MyFunctionnalInterfaceImpl());
// 2、创建一个匿名内部类，传递给show方法
show(new MyfunctionalInterface() {
@Override
public void method() {
System.out.println("这是使用匿名内部类来实现的");
}
});
// 3、使用Lambda表达式简化匿名内部类的书写
show(() -> {
System.out.println("这是使用Lambda表达式实现的");
});
}
public static void show(MyfunctionalInterface myInter) {
myInter.method();
}
}
注意：Lambda表达式在应用上可以看作是一种语法糖，简化了匿名内部类的书写，但是，事实上他他们的原理是不一样的（for each 表达式是简化迭代器书写的一种语法糖，他们的实现原理都是一样，都是使用迭代器），Lambda表达式不会生成一个class文件，但是使用匿名内部类会生成一个xxx$1.class文件。
2、函数式编程
2.1 延迟执行，函数式接口作为方法的参数
有时候，我们的代码的执行结果不会被马上使用，或者没有产生有用的结果，就会发生性能浪费的事情。就像下面的例子一样，一个方法的传递给方法的参数是三个字符串的拼接，也就是拼接字符串出现在判断level == 1之前，也就是说哪怕level ！= 1，也会初心字符串拼接，但是此时这些拼接的字符串就显得没有意义了，因为根本没有什么用。也就是发生了性能浪费。
package cn.zhuobo.day16.logger;
public class LoggerDemo1 {
public static void main(String[] args) {
String mess1 = "你是";
String mess2 = "猪猪";
String mess3 = "吗？";
showMessage(2, mess1 + mess2 + mess3);
}
public static void showMessage(int level, String message) {
if(level == 1) {
System.out.println(message);
}
}
}
Lambda表达式的延迟执行：把Lambda表达式作为参数传递到方法中，只有满足条件，这样才会执行Lambda表达式的代码块，这样就可以避免性能的浪费。
一个接口：
package cn.zhuobo.day16.logger;
@FunctionalInterface
public interface LoggerInterface {
public abstract String showMessage();// 返回String
}
性能优化：
package cn.zhuobo.day16.logger;
public class LoggerDemo02 {
public static void main(String[] args) {
String mess1 = "你是";
String mess2 = "猪猪";
String mess3 = "吗？";
method(2, () -> {
return mess1 + mess2 + mess3;
});
}
public static void method(int level, LoggerInterface logger) {
if(level == 1)
System.out.println(logger.showMessage());
}
}
仔细梳理一下就会发现：接口的抽象方法返回的是字符串，根据Lambda表达式，我们可以知道他返回的是一个拼接后的字符串。同时，在method方法中，只有level==1才会调用接口的showMessage方法，这样才会进行字符串的拼接，反之就不会进行字符串拼接。没有性能浪费现象。
2.2 函数式接口作为方法的返回值
如果一个方法返回的是一个函数式接口，那么就可以返回一个Lambda表达式（当然也可以返回实现类对象，匿名内部类对象）
下面的例子是通过一个方法获得一个java.util.Comparator接口类型的对象作为Arrays.sort方法的参数，对数组进行排序，这个方法就返回一个函数式接口。
package cn.zhuobo.day16.functionalInterfaceReturn;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
public class Demo01 {
// 这个方法的返回值是一个函数式接口，那么可以返回一个匿名内部类
public static Comparator<String> getComparator1() {
return new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length() - o2.length();// 按照字符串的长度升序排序
}
};
}
// 这个方法的返回值是一个函数式接口，返回一个Lambda表达式
public static Comparator<String> getComparator2() {
return (o1, o2) -> o1.length() - o2.length();
}
public static void main(String[] args) {
String[] arr = {"aa", "bbbb", "ccccccccccc", "dd", "adf"};
System.out.println(Arrays.toString(arr));
Arrays.sort(arr, getComparator2());
System.out.println(Arrays.toString(arr));
}
}
2.3 常用的函数式接口
java.util.function中包含了大量的函数式接口
- java.util.function.Supplier
该接口仅包含一个无参数的方法T get(),用来获取一个泛型参数指定类型的对象数据（生产数据），指定接口的泛型T是什么，那么get方法就会生产（返回）什么类型的数据
package cn.zhuobo.day16.aboutFuntionalInterface;
import java.util.function.Supplier;
public class InterfaceSupplier {
public static String getString(Supplier<String> sup) {
//System.out.println("shshs");
return sup.get();
}
public static void main(String[] args) {// getString方法是函数式接口，因此可以传递Lambda表达式
String str = getString(() -> {return "bilibili";});
System.out.println(str);
}
}
- java.util.function.Consumer
Consumer接口是和Supplier接口相反，不是生产一个数据，而是消费一个数据，该接口中包含抽象方法void accept(T， t)，意思是消费一个数据，泛型T指定的是什么类型就消费什么类型的数据，至于具体怎么消费（也就是怎么使用数据），那就要根据自己的需要的（输出，运算.......）
package cn.zhuobo.day16.aboutFuntionalInterface;
import java.util.function.Consumer;
public class InterfaceConsumer {
// 一个函数式接口作为参数
public static void method(String message, Consumer<String> con) {
con.accept(message);
}
public static void method2(String message, Consumer<String> con1, Consumer<String> con2) {
con1.andThen(con2).accept(message);// 先将两个接口连接到一起再消费数据，但是还是调用者先消费，也就con1先消费
}
public static void main(String[] args) {
String message = "Hello";
// 参数里可以写Lambda表达式，字节决定如何重写accept方法，这里是是字符串翻转
method(message, (s) -> {
String reMessage = new StringBuilder(s).reverse().toString();
System.out.println(reMessage);
});
method2(message, (s) -> {
System.out.println(s.toUpperCase());
}, (s) -> {
System.out.println(s.toLowerCase());
});
}
}
- java.util.function.Predicate
该接口用来对某种类型的数据进行判断，结果返回一个boolean值，可以使用接口的一个抽象方法boolean test(T t)判断，结果符合条件返回true，否则返回false
Predicate接口中三个默认方法and、or、negate
package cn.zhuobo.day16.aboutFuntionalInterface;
import java.util.function.Predicate;
public class InterfacePredicate {
// 一个条件
public static boolean stringPredicate1(String message, Predicate<String> pre){
return pre.test(message);// 调用test对message进行判断
}
// and方法
public static boolean stringPredicate2(String message, Predicate<String> pre1, Predicate<String> pre2) {
//return pre1.test(message) && pre2.test(message);
// 使用and方法有一样的效果
return pre1.and(pre2).test(message);
}
// or方法
public static boolean stringPredicate3(String message, Predicate<String> pre1, Predicate<String> pre2) {
//return pre1.test(message) && pre2.test(message);
// 使用and方法有一样的效果
return pre1.or(pre2).test(message);
}
//negate方法
public static boolean stringPredicate4(String message, Predicate<String> pre){
return pre.negate().test(message);// 调用test对message进行判断
}
public static void main(String[] args) {
String message = "hellollo";
boolean b1 = stringPredicate1(message, (str) -> {// 这里写判断的逻辑
return str.length() > 6;
});
System.out.println(b1);
boolean b2 = stringPredicate2(message, (str)->{
return str.length() > 6;
}, (str)->{
return str.contains("j");
});
System.out.println(b2);
}
}
- java.util.function.Function<T, R>
该接口用来根据一个类型的数据的到另一个类型的数据，前者为前置条件，后者为后置条件。该接口最主要的抽象方法是 R apply（T, t),根据T类型的参数获取R类型的参数
默认方法：andthen，与consumer接口类似的情况，当使用两个Function接口作为方法的参数时，就可以类似的使用（也就是可以使用andThen方法，将两次转换连接到一起，还是一样的先进行andThen的调用者。）