在 Kotlin 中有条件地组合 Lambda 以使用多个谓词进行过滤

Question

假设我有以下谓词作为村民 POJO 的预定义 lambda。

    val matchesSearch: (Villager, String) -> Boolean =
        { villager: Villager, query: String -> villager.name.contains(query) }

    val matchesGender: (Villager, Int) -> Boolean =
        { villager: Villager, filter: Int -> filter == villager.gender }

    val matchesPersonality: (Villager, Int) -> Boolean =
        { villager: Villager, filter: Int -> filter == villager.personality }

    val matchesSpecies: (Villager, Int) -> Boolean =
        { villager: Villager, filter: Int -> filter == villager.species }

    val matchesHobby: (Villager, Int) -> Boolean =
        { villager: Villager, filter: Int -> filter == villager.hobby }

我只想在满足特定条件时应用谓词。例如，如果应用了性别过滤器，则仅按性别过滤。或者我只想匹配已输入的搜索查询。

fun getVillagersThatMatchQueryAndFilters(list: List<Villager>): List<Villager> {

    val conditions = ArrayList<Predicate<Villager>>()

    if (searchQuery.isNotEmpty()) {
        // TODO: apply the matchesSearch() predicate lambda
        conditions.add(Predicate { villager -> villager.name.contains(query) })
    }
    if (genderFilter > 0) {
        // TODO: apply the matchesGender() predicate lambda
        conditions.add(Predicate { genderFilter == villager.gender })
    }
    if (personalityFilter > 0) {
        // TODO: apply the matchesPersonality() predicate lambda
        conditions.add(Predicate { personalityFilter == villager.personality })
    }
    if (speciesFilter > 0) {
        // TODO: apply the matchesSpecies() predicate lambda
        conditions.add(Predicate { speciesFilter == villager.species })
    }
    if (hobbyFilter > 0) {
        // TODO: apply the matchesHobby() predicate lambda
        conditions.add(Predicate { hobbyFilter == villager.hobby })
    }

    return list.filter {
        // TODO: match on all conditionally applied predicates
        conditions.allPredicatesCombinedWithAnd() // this doesn't actually exist
    }
}

之前我在每个条件下都完成了 list.filter{ } 并应用了必要的谓词，但是，因为我最多可以应用 5 个谓词，所以它对性能来说非常糟糕，因为它每次都会遍历列表.filter() 被调用。

有没有办法以编程方式迭代 List<Predicate<T>> 并将谓词与 .and() 或 && 组合，以便我可以一次应用过滤器？或者如果没有，我如何有条件地组合这些谓词？

我会使用最终的 Java 示例 here，它使用 Predicates.stream() 和 Collectors，但它需要 Android API 级别 24（高于我目前的 Android 分钟）。

下面的解决方案 - 感谢@Laurence and @IR42

的建议

适用于 < Android API 24

创建一个 lambda 列表并有条件地添加您希望与列表项匹配的任何谓词。然后使用 Collections.Aggregates.all() 方法确保您过滤所有谓词。（相当于对列表中的所有项目执行 pred1.and(pred2).and(etc.)...。）

如果您有大量要过滤的谓词，则可以节省大量性能，因为 list.filter() 仅调用一次。

fun getVillagersThatMatchQueryAndFilters(list: List<Villager>): List<Villager> {

    val conditions = ArrayList<(Villager) -> Boolean>()

    if (searchQuery.isNotEmpty()) {
        conditions.add{ it.name.contains(query) }
    }
    if (genderFilter > 0) {
        conditions.add{ genderFilter == it.gender }
    }
    if (personalityFilter > 0) {
        conditions.add{ personalityFilter == it.personality }
    }
    if (speciesFilter > 0) {
        conditions.add{ speciesFilter == it.species }
    }
    if (hobbyFilter > 0) {
        conditions.add{ hobbyFilter == it.hobby }
    }

    return list.filter { candidate -> conditions.all { it(candidate) } }
}

Answer 1

还有all extension function, and as a point of interest the any扩展功能。我认为您只需要在谓词的过滤器块中使用它们即可。这是一个非常简单的示例，其中包含一组愚蠢的谓词：

fun main() {
    val thingsToFilter = listOf(-1,2,5)

    val predicates = listOf(
        { value: Int -> value > 0 },
        { value: Int -> value > 4 }
    )

    val filtered = thingsToFilter.filter {candidate ->
        predicates.all{ it(candidate)}
    }

    print(filtered) // Outputs [5]

}

Answer 2

根据 Laurence 的回答，您可以创建这样的扩展程序

inline fun <T> Iterable<T>.filterAll(vararg predicates: (T) -> Boolean): List<T> {
    return filter { candidate ->
        predicates.all { it(candidate) }
    }
}

在 Kotlin 中有条件地组合 Lambda 以使用多个谓词进行过滤

Conditionally Combine Lambdas in Kotlin for Filtering with Multiple Predicates

android

predicate

filter

kotlin