Question

在Predicate的帮助下，我用Java编写了以下3种方法：

public static final Predicate<CustomerType> function1 = ct ->
        "OWNER".equals(ct.getFactType()) && "FULL".equals(ct.getFactValue());


public static final Predicate<CustomerType> function2 = ct ->
        "OWNER".equals(ct.getFactType()) && ("NONFULL".equals(ct.getFactValue()) || "FULL".equals(ct.getFactValue()));


public static final Predicate<CustomerType> function3 = ct ->
        ("INDIRECT".equals(ct.getFactType()) || "NONINDIRECT".equals(ct.getFactType()))
                && "YES".equals(ct.getFactValue());

如您所见，这三个函数有很多共同的元素（例如CustomerValue.getFactValue和CustomerValue.getFactType）。

在每三个函数中是否有办法将这些输入作为输入参数？如果是，怎么办？

我有以下方法，应该基于谓词为我提供布尔结果：

private boolean checkJohn(List<CustomerType> custTypes) {
    return custTypes.stream().anyMatch(Functional.method2);
}

private boolean checkJoan(List<CustomerType> custTypes) {
    return custTypes.stream().anyMatch(Functional.method1);
}

由于输入参数的数量不同，因为两个参数都可以具有A或B值，所以我有点困惑...

编辑：

如果我具有以下条件：

public static final BiPredicate<String, CustomerType> functionName = (ct, ft) ->
        ("NATPERSON".equals(ct) && ("INDIRECT".equals(ft.getFactType()) && "YES".equals(ft.getFactValue())))
                || ("NONNATPERS".equals(ct) && ("NONINDIRECT".equals(ft.getFactType()) && "YES".equals(ft.getFactValue())));

...这很好...

但是，如果我创建了：

Predicate<PersonType> IS_NATPERSON = wrap("NATPERSON"::equals); 
Predicate<PersonType> IS_NONNATPERSON = wrap("NONNATPERSON"::equals);

使用followinf包装：

private static Predicate<PersonType> wrap(Predicate<String> predicate) {
    return ft -> predicate.test(ft.getType().getCustomerType());
}

然后尝试通话：

public static final BiPredicate<PersonType, CustomerType> functionName2 = (IS_NATPERSON.and((IS_INDIRECT).and(IS_YES))).or(IS_NONNATPERSON.and((IS_NONINDIRECT).and(IS_YES)));

然后我明白了：

and (java.util.function.Predicate<? super PersonType>) in Predicate cannot be applied to (java.util.function.Predicate<CustomerType>)

有什么主意吗？

Answer 1

您可以使用BiPredicate类型，该类型带有两个参数。然后，调用.getFactType()和.getFactValue()就是调用者的工作。

您还可以通过为每个片段创建常量，然后使用.and和.or方法来组成常量来简化阅读过程：

static final BiPredicate<String, String> IS_OWNER = (t, v) -> "OWNER".equals(t);
// Etc

static final BiPredicate<String, String> f1 = IS_OWNER.and(IS_FULL);

// Using a BiPredicate by unwrapping a customer type:
if (f1.test(ct.getFactType(), ct.getFactValue())) {

理想情况下，事实类型和事实值的类型将有所不同，以免被意外混淆。

如果您不想将拆包责任推给调用者，则可以编写一个静态助手，将BiPredicate<String, String>变成Predicate<CustomerType>：

static Predicate<CustomerType> wrap(BiPredicate<String, String> bp) {
    return ct -> bp.test(ct.getFactType(), ct.getFactValue());
}

static final Predicate<CustomerType> IS_OWNER = wrap((t, v) -> "OWNER".equals(t));
// Etc

static final Predicate<CustomerType> f1 = IS_OWNER.and(IS_FULL);

具有通用输入参数的Java Predicate <t>

1 个答案: