scala 返回列表中的第一个 Some

Question

我有一个列表 l:List[T1] ，目前正在执行以下操作：

myfun : T1 -> Option[T2]
val x: Option[T2] = l.map{ myfun(l) }.flatten.find(_=>true)

myfun 函数返回 None 或 Some，flatten 丢弃所有 None，find 返回第一个列表的元素（如果有）。

这对我来说似乎有点老套。我认为可能存在一些理解或类似的东西，可以减少浪费或更聪明。 例如：如果 myfun 在列表 map 期间返回 any Some，我不需要任何后续答案>l。

Answer 1

怎么样：

l.toStream flatMap (myfun andThen (_.toList)) headOption

Stream 是惰性的，因此它不会提前映射所有内容，但也不会重新映射内容。不要将事物展平，而是将 Option 转换为 List，以便可以使用 flatMap。

Answer 2

除了使用toStream来使搜索变得懒惰之外，我们还可以使用Stream::collectFirst：

List(1, 2, 3, 4, 5, 6, 7, 8).toStream.map(myfun).collectFirst { case Some(d) => d }
// Option[String] = Some(hello)
// given def function(i: Int): Option[String] = if (i == 5) Some("hello") else None

此：

• 将 List 转换为 Stream，以便尽早停止搜索。

• 使用 myFun 作为 Option[T] 转换元素。

• 收集第一个非 None 的映射元素并提取它。

从 Scala 2.13 开始，随着 Stream 的弃用而转而使用 LazyList，这将变成：

List(1, 2, 3, 4, 5, 6, 7, 8).to(LazyList).map(function).collectFirst { case Some(d) => d }

Answer 3

好吧，这几乎，但不完全，

val x = (l flatMap myfun).headOption

但是您从 myfun 返回一个 Option 而不是 List，所以这可能不起作用。如果是这样（我手头没有 REPL），请尝试：

val x = (l flatMap(myfun(_).toList)).headOption

Answer 4

嗯，for-communeration 的等价物非常简单

(for(x<-l, y<-myfun(x)) yield y).headOption

，如果你真的进行翻译，其结果与 oxbow_lakes 给出的结果相同。假设 List.flatmap 有合理的惰性，这既是一个干净又有效的解决方案。

Answer 5

截至2017年，之前的答案似乎已经过时了。我运行了一些基准测试（1000 万个整数的列表，第一个匹配项大致在中间，Scala 2.12.3、Java 1.8.0、1.8 GHz Intel Core i5）。除非另有说明，list 和 map 具有以下类型：

list: scala.collection.immutable.List
map: A => Option[B]

只需在列表上调用 map：~1000 ms

list.map(map).find(_.isDefined).flatten

第一次调用 toStream< /code> 在列表上：~1200 ms

list.toStream.map(map).find(_.isDefined).flatten

在列表上调用 toStream.flatMap：~450 ms

list.toStream.flatMap(map(_).toList).headOption

在列表上调用 flatMap：~100 ms

list.flatMap(map(_).toList).headOption

第一次调用 iterator列表中的：约 35 毫秒

list.iterator.map(map).find(_.isDefined).flatten

递归函数 find()：约 25 毫秒

def find[A,B](list: scala.collection.immutable.List[A], map: A => Option[B]) : Option[B] = {
  list match {
    case Nil => None
    case head::tail => map(head) match {
      case None => find(tail, map)
      case result @ Some(_) => result
    }
  }
}

迭代函数 find()：约 25 毫秒

def find[A,B](list: scala.collection.immutable.List[A], map: A => Option[B]) : Option[B] = {
  for (elem <- list) {
    val result = map(elem)
    if (result.isDefined) return result
  }
  return None
}

您可以通过以下方式进一步加快速度：使用 Java 而不是 Scala 集合以及功能较少的风格。

循环遍历 java.util.ArrayList 中的索引：~15 ms

def find[A,B](list: java.util.ArrayList[A], map: A => Option[B]) : Option[B] = {
  var i = 0
  while (i < list.size()) {
    val result = map(list.get(i))
    if (result.isDefined) return result
    i += 1
  }
  return None
}

循环遍历 java.util.ArrayList 中的索引，函数返回 null 而不是 < code>None：~10 ms

def find[A,B](list: java.util.ArrayList[A], map: A => B) : Option[B] = {
  var i = 0
  while (i < list.size()) {
    val result = map(list.get(i))
    if (result != null) return Some(result)
    i += 1
  }
  return None
}

（当然，通常会将参数类型声明为 java.util.List，而不是 java.util.ArrayList。我在这里选择了后者，因为它是我用于基准测试的类。java.util.List 的其他实现将显示不同的性能 - 大多数都会更差。）