提升java业务代码优雅度之函数式接口编程
如何提高java代码优雅度，java8中函数式编程是不得不提的一个重要模块。下面直奔主题：
一.函数式接口的定义
-
被@FunctionalInterface注释的接口，满足@FunctionalInterface注释的约束；
- 没有被@FunctionalInterface注释的接口，但是满足@FunctionalInterface注释的约束。
二.@FunctionalInterface注释的约束
- 接口有且只能有个一个抽象方法，只有方法定义，没有方法体；
- 在接口中覆写Object类中的public方法，不算是函数式接口的方法。
示例：
/**
*
* @author zhaoj
* @version FunctionInterfaceTest.java, v 0.1 2019-09-04 17:53
*/
@FunctionalInterface
public interface FunctionInterfaceTest {
/**
* 自定义方法
* @param input
* @return
*/
String fetch(String input);
/**
* Object中的方法
*/
@Override
String toString();
/**
* Object中的方法
* @param obj
* @return
*/
@Override
boolean equals(Object obj);
}
三.函数式接口实例的创建
函数式接口实例的创建有三种方式：
1、lambda表达式；
2、方法引用；
3、构造方法引用。
三种示例：
/**
*
* @author zhaoj
* @version FunctionalInterfaceTest0.java, v 0.1 2019-09-04 17:51
*/
public class FunctionalInterfaceTest0 {
public static void main(String[] args) {
/**
* 1、lambda表达式
*/
FunctionInterfaceTest functionInterfaceTest1 = item -> item;
/**
* 2、方法引用
*/
FunctionInterfaceTest functionInterfaceTest2 = FunctionalInterfaceTest0::getInstance;
FunctionInterfaceTest functionInterfaceTest3 = FunctionalInterfaceTest0::getMessage;
String msg1 = join("hello",functionInterfaceTest2);
System.out.println(msg1);
String msg2 = join("hello",functionInterfaceTest3);
System.out.println(msg2);
/**
* 3、构造方法引用
*/
FunctionInterfaceTest functionInterfaceTest4 = String::new;
}
public static String getInstance(String item){
return item+"！world";
}
public static String getMessage(String massage){
return "world,"+ massage+"!";
}
public static String join(String str,FunctionInterfaceTest functionTest){
return functionTest.fetch(str);
}四.java8中常用的函数式接口
常用的函数式接口主要有四种类型，是通过其输入和输出的参数来进行区分的：
| 接口名 |
说明 |
| Function |
接收一个T类型的参数，返回一个R类型的结果 |
| Consumer |
接收一个T类型的参数，不返回值 |
| Predicate |
接收一个T类型的参数，返回一个boolean类型的结果 |
| Supplier |
不接受参数，返回一个T类型的结果 |
示例：
/**
* @author zhaoj
* @version FunctionalInterfaceTest1.java, v 0.1 2019-09-05 9:34
*/
public class FunctionalInterfaceTest1 {
public static void main(String[] args) {
//1.第一种创建方式 接收一个T类型的参数，返回一个R类型的结果
Function function1 = item -> item + "返回值";
//第二种创建方式，接收一个T类型的参数，不返回值，lambda语句，使用大括号，没有return关键字，表示没有返回值
Consumer function2 = item -> {
System.out.println(item);
};
//第三种创建方式，接收一个T类型的参数，返回一个boolean类型的结果
PredicateTest function3 = item -> "".equals(item);
//第四种创建方式，不接受参数，返回一个T类型的结果
Supplier function4 = () -> new String("123");
/**
* 1、创建一个String类型的集合
* 2、将集合中的所有元素的末尾追加字符串'1'
* 3、选出长度大于2的字符串
* 4、遍历输出所有元素
*/
List list = Arrays.asList("zhangsan", "lisi", "wangwu", "xiaoming", "zhaoliu");
list.stream()
//传入的是一个Function函数式接口
.map(value -> value + "666")
//传入的是一个Predicate函数式接口
.filter(value -> value.length() > 5)
//传入的是一个Consumer函数式接口
.forEach(value -> {
System.out.println(value);
});
}
} Java8中对于接收两个参数的场景提供了相关的函数式接口：
| 接口名 |
说明 |
| BiFunction |
接收T类型和U类型的两个参数，返回一个R类型的结果 |
| BiConsumer |
接收T类型和U类型的两个参数，不返回值 |
| BiPredicate |
接收T类型和U类型的两个参数，返回一个boolean类型的结果 |
示例：
/**
*
* @author zhaoj
* @version FunctionalInterfaceTest2.java, v 0.1 2019-09-05 17:43
*/
public class FunctionalInterfaceTest2 {
public static void main(String[] args) {
/**
* Bi类型的接口创建
*/
BiFunction biFunction = (str1, str2) -> str1.length() + str2.length();
BiConsumer biConsumer = (str1, str2) -> System.out.println(str1 + str2);
BiPredicate biPredicate = (str1, str2) -> str1.length() > str2.length();
}
/**
* Bi类型的接口使用
*/
//输出10
int length = getLength("hello", "world", (str1, str2) -> str1.length() + str2.length());
//输出false
boolean boolean1 = getBoolean("hello", "world", (str1, str2) -> str1.length() > str2.length());
System.out.println(length);
System.out.println(boolean1);
//没有输出
noResult("hello", "world", (str1, str2) -> System.out.println(str1 + " " + str2));
}
public static int getLength(String str1, String str2, BiFunction function) {
return function.apply(str1, str2);
}
public static void noResult(String str1, String str2, BiConsumer biConcumer) {
biConcumer.accept(str1, str2);
}
public static boolean getBoolean(String str1, String str2, BiPredicate biPredicate) {
return biPredicate.test(str1, str2);
}
} 关于多个参数值的使用，无论实在Function接口中，还是在BI类型的接口都提供了类似的操作。（注:java8中，接口的方法是可以有实现的，但需要default关键字修饰，这是其他版本的jdk没有的特性）
1、 Function接口的andThen方法和compose方法
default Function compose(Function before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
default Function andThen(Function after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
} 解释说明:
Compose方法：方法接收一个Function类型的参数，返回一个值。这也是一个标准的Function类型的定义。在compose方法内部也有一个apply方法。在执行compose方法中的apply方法之前，它先执行了before接口的apply方法，也是compose方法的输入参数。然后将before方法执行的返回值作为compose中apply方法的输入参数。
andThen方法：该方法与compose方法很类似。不同之处在于，andThen是先执行自身的apply方法，将apply的返回值作为after接口的输入值。相对于compose方法，只是顺序的不同。
2、Consumer接口的andThen方法
default Consumer andThen(Consumer after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
} 解释说明：
将输入参数分别赋给andThen内部的accept方法和after内部的accept方法。After的计算在andThen之后，起到了后置连接的作用。在这里没有compose方法，因为后置连接反过来就是前置连接，所以不需要一个多余的compose方法了。只需要在传递时，交换两个consumer的顺序即可。
3、 predicate接口的and、or、negate方法
default Predicate and(Predicate other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate negate() {
return (t) -> !test(t);
}
default Predicate or(Predicate other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
} 解释说明：
分别是与 ，非，或操作。
此外，java8针对原生类型int，long，double都提供了相应的函数式接口，使用方式都相同，见java.util.function包。
五.自定义使用
//自定义T,U两个入参,无返回参数,用于构建组装信息
@FunctionalInterface
public interface Builder {
void build(T t, U u);
}
//自定义T,U两个入参,返回验证结果
@FunctionalInterface
public interface Verification {
boolean verify(T t, U u);
}
//自定义工具类
public class Util {
public static List buildParam(List left, List right, Verification verifyer, Builder builder) {
if (left.isEmpty() || right.isEmpty()) {
return left;
}
left.forEach(l -> right.forEach(r -> {
if (verifyer.verify(l, r)) {
builder.build(l, r);
return;
}
}));
return left;
}
}