Kotlin 过滤，减法或分组-什么是最有效的？（科特林）

例如，我们有一个列表，我们想用特定的谓词将其分为两部分

首先，我们可以使用

filter

和

filterNot

val trueList = list.filter(predicate)
val falseList = list.filterNot(predicate)

其次，我们可以使用

过滤器

和

减法

：

val trueList = list.filter(predicate)
val falseList = list.subtract(trueList)

第三，我们可以使用

groupBy

：

val groupBy = list.groupBy(predicate)
val trueList = groupBy[true]
val falseList = groupBy[false]

最有效、最快的方法是什么？我们可以用其他函数来实现吗

---

我认为第二个选项是

减法
是最差的，对吗？
因此，我试图了解哪个选项最快：
过滤
，
减法
，
分组比
或
分区
（谢谢提示）。我使用
measureTimeMillis
了解每个选项的运行时间：

private fun checkTime(list: List<Int>, predicate: (Int) -> Boolean) {
    var sum = 0L
    repeat(times) { sum += checkPartition(list, predicate) }
    println("partition: ${sum/times}")

    sum = 0L
    repeat(times) { sum += checkFilter(list, predicate) }
    println("filter: ${sum/times}")

    sum = 0L
    repeat(times) { sum += checkSubtract(list, predicate) }
    println("subtract: ${sum/times}")

    sum = 0L
    repeat(times) { sum += checkGroupBy(list, predicate) }
    println("group by: ${sum/times}")
}


private fun checkGroupBy(list: List<Int>, predicate: (Int) -> Boolean): Long {
    return measureTimeMillis {
        val groupBy = list.groupBy(predicate)
        val falseList = groupBy[false]
        val trueList = groupBy[true]
    }
}

private fun checkSubtract(list: List<Int>, predicate: (Int) -> Boolean): Long {
    return measureTimeMillis {
        val trueList = list.filter(predicate)
        val falseList = list.subtract(trueList)
    }
}

private fun checkFilter(list: List<Int>, predicate: (Int) -> Boolean): Long {
    return measureTimeMillis {
        val trueList = list.filter(predicate)
        val falseList = list.filterNot(predicate)
    }
}

private fun checkPartition(list: List<Int>, predicate: (Int) -> Boolean): Long {
    return measureTimeMillis {
        val pair = list.partition(predicate)
        val trueList = pair.first
        val falseList = pair.second
    }
}

对于不同大小的列表：

var list = (1..1_000_000).toList()
checkTime(list, predicate)

分区：16
过滤器：21
减：81
组别：18

分区：30
过滤器：42
减：241
组别：36

分区：35
过滤器：59
减：233
组别：63

所以，将列表分成两部分是一个非常好的选择

如果我做错了什么，请告诉我。
您错过了最明显的选择：。感谢
分区
，我知道应该有一个简单的选项。分区案例仅供参考。您可以利用Kotlin的解构操作。因此它变成了
val（trueList，false list）=list.partition（predicate）
。IntelliJ甚至将其作为一种意图提供，并将为您更改代码。
var list = (1..1_000_000).toList()
checkTime(list, predicate)

list = (1..2_000_000).toList()
checkTime(list, predicate)

list = (1..3_000_000).toList()
checkTime(list, predicate)