搜索热词
前言
方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。方法引用提供了一种引用而不执行方法的方式，它需要由兼容的函数式接口构成的目标类型上下文。计算时，方法引用会创建函数式接口的一个实例。
当Lambda表达式中只是执行一个方法调用时，不用Lambda表达式，直接通过方法引用的形式可读性更高一些。方法引用是一种更简洁易懂的Lambda表达式。
注意：方法引用是一个Lambda表达式，其中方法引用的操作符是双冒号"::"。
在Java8中，使用方法引用非常简单，如String::isEmpty，但无法使用它否定的方法引用。本文内容即如何解决此问题使得我们能够更加全面地使用方法引用。
首先看一个使用方法引用的例子：
Stream.of("A","","B").filter(String::isEmpty).count()
上面代码的输出为1，即空字符串的数目。如果我们想要获取非空字符串的数目，就不能直接使用方法引用了。
Stream.of("A","B").filter(s -> !s.isEmpty()).count()
Java8中的Predicate，有predicate.negate()可以转换为断言的否定形式，但String::isEmpty却无法这么做(String::isEmpty.negate()或者!String::isEmpty )。因为方法引用并不是一个lambda或者函数接口，它能够被解析为一个或者多个函数接口。如，String::isEmpty至少可以被解析如下：
Predicate
Function
为了解决上述的问题，我们可以通过某种机制显式地将方法引用转换为一个函数接口：
public static Predicate as(Predicate predicate) {
return predicate;
}
通过使用一个静态方法，接受方法引用参数，返回一个函数接口，即可实现方法引用到函数接口的转换。接着，我们就可以使用方法引用来实现上面例子中的获取非空字符串的数目。
Stream.of("A","B").filter(as(String::isEmpty).negate()).count();
进一步还能使用各种组合的Predicate。
.filter(as(String::isEmpty).negate().and("A"::equals))
由于一个方法引用可能会被解析为多种函数接口，因此如果我们实现很多参数不同的as方法，那么很容易造成混淆。更好的方式则是在方法名中加入函数参数的类型来区分。
import java.util.function.*;
public class FunctionCastUtil {
public static BiConsumer asBiConsumer(BiConsumer biConsumer) {
return biConsumer;
}
public static BiFunction asBiFunction(BiFunction biFunction) {
return biFunction;
}
public static BinaryOperator asBinaryOperator(BinaryOperator binaryOperator) {
return binaryOperator;
}
public static BiPredicate asBiPredicate(BiPredicate biPredicate) {
return biPredicate;
}
public static BooleanSupplier asBooleanSupplier(BooleanSupplier booleanSupplier) {
return booleanSupplier;
}
public static Consumer asConsumer(Consumer consumer) {
return consumer;
}
public static DoubleBinaryOperator asDoubleBinaryOperator(DoubleBinaryOperator doubleBinaryOperator) {
return doubleBinaryOperator;
}
public static DoubleConsumer asDoubleConsumer(DoubleConsumer doubleConsumer) {
return doubleConsumer;
}
public static DoubleFunction asDoubleFunction(DoubleFunction doubleFunction) {
return doubleFunction;
}
public static DoublePredicate asDoublePredicate(DoublePredicate doublePredicate) {
return doublePredicate;
}
public static DoubleToIntFunction asDoubleToIntFunction(DoubleToIntFunction doubleToIntFunctiontem) {
return doubleToIntFunctiontem;
}
public static DoubleToLongFunction asDoubleToLongFunction(DoubleToLongFunction doubleToLongFunction) {
return doubleToLongFunction;
}
public static DoubleUnaryOperator asDoubleUnaryOperator(DoubleUnaryOperator doubleUnaryOperator) {
return doubleUnaryOperator;
}
public static Function asFunction(Function function) {
return function;
}
public static IntBinaryOperator asIntBinaryOperator(IntBinaryOperator intBinaryOperator) {
return intBinaryOperator;
}
public static IntConsumer asIntConsumer(IntConsumer intConsumer) {
return intConsumer;
}
public static IntFunction asIntFunction(IntFunction intFunction) {
return intFunction;
}
public static IntPredicate asIntPredicate(IntPredicate intPredicate) {
return intPredicate;
}
public static IntSupplier asIntSupplier(IntSupplier intSupplier) {
return intSupplier;
}
public static IntToDoubleFunction asIntToDoubleFunction(IntToDoubleFunction intToDoubleFunction) {
return intToDoubleFunction;
}
public static IntToLongFunction asIntToLongFunction(IntToLongFunction intToLongFunction) {
return intToLongFunction;
}
public static IntUnaryOperator asIntUnaryOperator(IntUnaryOperator intUnaryOperator) {
return intUnaryOperator;
}
public static LongBinaryOperator asLongBinaryOperator(LongBinaryOperator longBinaryOperator) {
return longBinaryOperator;
}
public static LongConsumer asLongConsumer(LongConsumer longConsumer) {
return longConsumer;
}
public static LongFunction asLongFunction(LongFunction longFunction) {
return longFunction;
}
public static LongPredicate asLongPredicate(LongPredicate longPredicate) {
return longPredicate;
}
public static LongSupplier asLongSupplier(LongSupplier longSupplier) {
return longSupplier;
}
public static LongToDoubleFunction asLongToDoubleFunction(LongToDoubleFunction longToDoubleFunction) {
return longToDoubleFunction;
}
public static LongToIntFunction asLongToIntFunction(LongToIntFunction longToIntFunction) {
return longToIntFunction;
}
public static LongUnaryOperator asLongUnaryOperator(LongUnaryOperator longUnaryOperator) {
return longUnaryOperator;
}
public static ObjDoubleConsumer asObjDoubleConsumer(ObjDoubleConsumer objDoubleConsumer) {
return objDoubleConsumer;
}
public static ObjIntConsumer asObjIntConsumer(ObjIntConsumer objIntConsumer) {
return objIntConsumer;
}
public static ObjLongConsumer asObjLongConsumer(ObjLongConsumer objLongConsumer) {
return objLongConsumer;
}
public static Predicate asPredicate(Predicate predicate) {
return predicate;
}
public static Supplier asSupplier(Supplier supplier) {
return supplier;
}
public static ToDoubleBiFunction asToDoubleBiFunction(ToDoubleBiFunction toDoubleBiFunction) {
return toDoubleBiFunction;
}
public static ToDoubleFunction asToDoubleFunction(ToDoubleFunction toDoubleFunction) {
return toDoubleFunction;
}
public static ToIntBiFunction asToIntBiFunction(ToIntBiFunction toIntBiFunction) {
return toIntBiFunction;
}
public static ToIntFunction asToIntFunction(ToIntFunction ioIntFunction) {
return ioIntFunction;
}
public static ToLongBiFunction asToLongBiFunction(ToLongBiFunction toLongBiFunction) {
return toLongBiFunction;
}
public static ToLongFunction asToLongFunction(ToLongFunction toLongFunction) {
return toLongFunction;
}
public static UnaryOperator asUnaryOperator(UnaryOperator unaryOperator) {
return unaryOperator;
}
private FunctionCastUtil() {
}
}
Stream.of("A","B").filter(asPredicate(String::isEmpty).negate()).count();
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对编程小技巧的支持。
相关文章
总结
如果觉得编程之家网站内容还不错，欢迎将编程之家网站推荐给程序员好友。
本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您喜欢交流学习经验，点击链接加入交流1群：1065694478(已满)交流2群：163560250
9681
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
