如何一次通过多个谓词过滤列表？

Question

假设我通过几个谓词过滤一个列表，例如

val xs = List(1, 0, -1, 2, 3, 4, 5, -6, 5, 0)
val pred1: Int => Boolean = _ > 0
val pred2: Int => Boolean = _ < 0
val pred3: Int => Boolean = _ % 2 == 0

val xs1 = xs.filter(pred1) // List(1, 2, 3, 4, 5, 5)
val xs2 = xs.filter(pred2) // List(-1, -6)
val xs3 = xs.filter(pred3) // List(0, 2, 4, -6, 0)

如何一次通过所有这些谓词过滤列表？

def filterByFew(xs: List[Int], preds: List[Int => Boolean]): List[List[Int]] = ???

filterByFew(xs, List(pred1, pred2, pred3)) 应该返回
List(List(1, 2, 3, 4, 5, 5), List(-1, -6), List(0, 2, 4, -6, 0))

Answer 1

仍然会多次遍历集合的单行答案：

List(pred1, pred2, pred3).map(xs.filter)

作为方法：

def filterByFew(xs: List[Int], preds: List[Int => Boolean]): List[List[Int]] = 
  preds.map(xs.filter)

它以几乎相同的方式处理流：

val p1 = (x: Int) => x % 2 == 0
val p2 = (x: Int) => x % 3 == 0

val preds = List(p1, p2)
val str = Stream.from(0)

val filteredStreams = preds.map(str.filter)
filteredStreams foreach { s => println(s.take(10).toList) }

// Output:
// List(0, 2, 4, 6, 8, 10, 12, 14, 16, 18)
// List(0, 3, 6, 9, 12, 15, 18, 21, 24, 27)

但不要在 REPL 中尝试：REPL 会自行挂起为什么要显示中间结果。

---

遍历集合一次

如果您真的不能多次遍历集合，那么我看不到任何有效的解决方法，最简单的方法似乎是重新实现 filter，但使用多个可变构建器：

def filterByMultiple[A](
  it: Iterator[A],
  preds: List[A => Boolean]
): List[List[A]] = {
  val n = preds.size
  val predsArr = preds.toArray
  val builders = Array.fill(n){
    new collection.mutable.ListBuffer[A]
  }
  for (a <- it) {
    for (j <- 0 until n) {
      if (predsArr(j)(a)) {
        builders(j) += a
      }
    }
  }
  builders.map(_.result)(collection.breakOut)
}


filterByMultiple((0 to 30).iterator, preds) foreach println
// Output:
// List(0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30)
// List(0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30)

---

如果您是通过 Google 搜索来到这里的，那么您可能想要别的东西：

AND-ing 多个谓词：

def filterByAnd(xs: List[Int], preds: List[Int => Boolean]) = 
  xs.filter(x => preds.forall(p => p(x)))

OR-ing 多个谓词：

def filterByOr(xs: List[Int], preds: List[Int => Boolean]) = 
  xs.filter(x => preds.exists(p => p(x)))

Answer 2

我相信 Andrey Tyukin 的回答并没有解决问题的“一次性”方面。如果不必保留元素的顺序，那么我认为以下实现将相当有效：

def filterByFew[A](xs: Traversable[A], preds: List[A => Boolean]): List[List[A]] = {
  xs.foldLeft(List.fill(preds.size)(List.empty[A]))((acc, el) => {
    acc.zip(preds).map({
      case (l, p) => if (p(el)) el :: l else l
    })
  })
}

如果必须保留顺序，简单的解决方案是反转filterByFew 末尾的所有内部列表，但如果过滤器不是很有选择性，它实际上是多次迭代整个集合。另一种解决方案是这样的：

def filterByFew2[A](xs: Traversable[A], preds: List[A => Boolean]): List[Traversable[A]] = {
  val builders = xs.foldLeft(List.fill(preds.size)(xs.companion.newBuilder[A]))((acc, el) => {
    acc.zip(preds).foreach({
      case (b, p) => if (p(el)) b += el
    })
    acc
  })
  builders.map(b => b.result())
}

FP 更少，但性能更好。其实这类似于filter在标准库中的实现方式。

一个简单的测试来确保它像声称的那样工作是这样的：

def test(): Unit = {
  val xs0 = List(1, 0, -1, 2, 3, 4, 5, -6, 5, 0)
  val xs = xs0.view.map(x => {
    println(s"accessing $x")
    x
  })
  val pred1: Int => Boolean = _ > 0
  val pred2: Int => Boolean = _ < 0
  val pred3: Int => Boolean = _ % 2 == 0
  val preds = List(pred1, pred2, pred3)
  val res = preds.map(xs.filter)
  println(res)
  println("---------------")
  println(filterByFew(xs, preds))
  println("---------------")
  println(filterByFew2(xs, preds))

}

view 是惰性方法，因此我们将记录对底层集合的每次访问。很容易看出，Andrey 的代码访问每个元素 3 次，而我的解决方案只访问一次。