在Java 8中，你可以使用方法引用来过滤流，例如:
Stream<String> s = ...;
long emptyStrings = s.filter(String::isEmpty).count();
是否有一种方法可以创建一个方法引用，它是现有方法引用的否定，例如:
long nonEmptyStrings = s.filter(not(String::isEmpty)).count();
我可以创建如下所示的not方法，但我想知道JDK是否提供了类似的东西。
static <T> Predicate<T> not(Predicate<T> p) { return o -> !p.test(o); }
当前回答
另一种选择是在明确的上下文中使用lambda强制转换为一个类:
public static class Lambdas {
public static <T> Predicate<T> as(Predicate<T> predicate){
return predicate;
}
public static <T> Consumer<T> as(Consumer<T> consumer){
return consumer;
}
public static <T> Supplier<T> as(Supplier<T> supplier){
return supplier;
}
public static <T, R> Function<T, R> as(Function<T, R> function){
return function;
}
}
．.． 然后静态导入实用程序类:
stream.filter(as(String::isEmpty).negate())
其他回答
提示:要否定collection.stream().anyMatch(…)，可以使用collection.stream().noneMatch(…)
在这种情况下，你可以使用org.apache.commons.lang3.StringUtilsand
int nonEmptyStrings = s.filter(StringUtils::isNotEmpty).count();
另一种选择是在明确的上下文中使用lambda强制转换为一个类:
public static class Lambdas {
public static <T> Predicate<T> as(Predicate<T> predicate){
return predicate;
}
public static <T> Consumer<T> as(Consumer<T> consumer){
return consumer;
}
public static <T> Supplier<T> as(Supplier<T> supplier){
return supplier;
}
public static <T, R> Function<T, R> as(Function<T, R> function){
return function;
}
}
．.． 然后静态导入实用程序类:
stream.filter(as(String::isEmpty).negate())
谓词。不是(…)
java-11提供了一个新方法Predicate#not
所以你可以对reference方法求反:
Stream<String> s = ...;
long nonEmptyStrings = s.filter(Predicate.not(String::isEmpty)).count();
我已经编写了一个完整的实用程序类(受到Askar的建议的启发)，它可以接受Java 8 lambda表达式，并将它们(如果适用)转换为包Java .util.function中定义的任何类型的标准Java 8 lambda。你可以这样做:
asPredicate（String：：isEmpty）.negate（） asBiPredicate（String：：equals）.negate（）
因为如果所有静态方法都以as()命名，将会产生许多歧义，所以我选择调用方法“as”，后面跟着返回的类型。这使我们能够完全控制lambda解释。下面是实用工具类的第一部分(有点大)，揭示了所使用的模式。
在这里查看完整的课程(要点)。
public class FunctionCastUtil {
public static <T, U> BiConsumer<T, U> asBiConsumer(BiConsumer<T, U> biConsumer) {
return biConsumer;
}
public static <T, U, R> BiFunction<T, U, R> asBiFunction(BiFunction<T, U, R> biFunction) {
return biFunction;
}
public static <T> BinaryOperator<T> asBinaryOperator(BinaryOperator<T> binaryOperator) {
return binaryOperator;
}
... and so on...
}
