如何读取扩展 Any 但不扩展 AnyRef 的 Scala 对象的类？

Question

我有一个如下所示的异构列表：

val l = List(1, "One", true)

并且我需要通过仅提取属于给定类的对象来过滤其对象。为此，我编写了一个非常简单的方法，如下所示：

def filterByClass[A](l: List[_], c: Class[A]) =
  l filter (_.asInstanceOf[AnyRef].getClass() == c)

请注意，我有义务向 AnyRef 添加显式转换，以避免此编译问题：

error: type mismatch;
found   : _$1 where type _$1
required: ?{val getClass(): ?}
Note that implicit conversions are not applicable because they are ambiguous:
both method any2stringadd in object Predef of type (x: Any)scala.runtime.StringAdd
and method any2ArrowAssoc in object Predef of type [A](x: A)ArrowAssoc[A]
are possible conversion functions from _$1 to ?{val getClass(): ?}
l filter (_.getClass() == c)

但是，通过这种方式，调用：

filterByClass(l, classOf[String])

按预期返回：

List(One)

但当然同样不会例如，对于 Int 不起作用，因为它们扩展了 Any 但不是 AnyRef，因此通过调用：

filterByClass(l, classOf[Int])

结果只是空 List。

有没有办法让我的 filterByClass 方法甚至可以与 Int、Boolean 和扩展 Any 的所有其他类一起使用？

Answer 1

collect 方法已经完成了您想要的操作。例如，要收集集合中的所有 Int，您可以编写

xs collect { case x: Int => x }

这当然仅在您对类型进行硬编码时才有效，但由于基元的处理方式与引用类型不同，因此实际上最好这样做。您可以使用某些类型类让您的生活更轻松：

case class Collect[A](collect: PartialFunction[Any,A])

object Collect {

  implicit val collectInt: Collect[Int] = Collect[Int]({case x: Int => x})

  // repeat for other primitives

  // for types that extend AnyRef
  implicit def collectAnyRef[A <: AnyRef](implicit mf: ClassManifest[A]) =
    Collect[A]({ case x if mf.erasure.isInstance(x) => x.asInstanceOf[A] })
}

def collectInstance[A : Collect](xs: List[_ >: A]) =
  xs.collect(implicitly[Collect[A]].collect)

然后您甚至可以在不传递 Class[A] 实例的情况下使用它：

scala> collectInstance[Int](l)
res5: List[Int] = List(1)

scala> collectInstance[String](l)
res6: List[String] = List(One)

Answer 2

使用 isInstanceOf:

scala> val l = List(1, "One", 2)
l: List[Any] = List(1, One, 2)

scala> l . filter(_.isInstanceOf[String])
res1: List[Any] = List(One)

scala> l . filter(_.isInstanceOf[Int])
res2: List[Any] = List(1, 2)

---

编辑：
根据OP的要求，这是另一个将检查移入方法的版本。我找不到使用 isInstanceOf 的方法，因此我更改了实现以使用 ClassManifest：

def filterByClass[A](l: List[_])(implicit mf: ClassManifest[A]) =
  l.filter(mf.erasure.isInstance(_))

一些使用场景：

scala> filterByClass[String](l)
res5: List[Any] = List(One)

scala> filterByClass[java.lang.Integer](l)
res6: List[Any] = List(1, 2)

scala> filterByClass[Int](l)
res7: List[Any] = List()

如上所示，此解决方案不适用于 Scala 的 Int 类型。

Answer 3

List[Any] 中元素的类永远不是 classOf[Int]，因此其行为符合预期。你的假设显然让这出乎意料，但很难给你更好的方法，因为正确的方法是“不要这样做”。

您认为关于异构列表的成员的类别可以说些什么？也许这很说明问题。我很好奇你认为 java 是如何做得更好的。

scala> def f[T: Manifest](xs: List[T]) = println(manifest[T] + ", " + manifest[T].erasure)
f: [T](xs: List[T])(implicit evidence$1: Manifest[T])Unit

scala> f(List(1))
Int, int

scala> f(List(1, true))
AnyVal, class java.lang.Object

scala> f(List(1, "One", true))
Any, class java.lang.Object

Answer 4

这对我有用。这是你想要的吗？

scala> val l = List(1, "One", true)
l: List[Any] = List(1, One, true)

scala> l filter { case x: String => true; case _ => false }
res0: List[Any] = List(One)

scala> l filter { case x: Int => true; case _ => false }
res1: List[Any] = List(1)

scala> l filter { case x: Boolean => true; case _ => false }
res2: List[Any] = List(true)

Answer 5

尽管我的解决方案可能不如 这个我发现我的更快更容易。我刚刚定义了一个这样的方法：

private def normalizeClass(c: Class[_]): Class[_] =
  if (classOf[AnyRef].isAssignableFrom((c))) c
  else if (c == classOf[Int]) classOf[java.lang.Integer]
  // Add all other primitive types
  else classOf[java.lang.Boolean]

因此，通过在我以前的 filterByClass 方法中使用它，如下所示：

def filterByClass[A](l: List[_], c: Class[A]) =
  l filter (normalizeClass(c).isInstance(_))

的调用：

filterByClass(List(1, "One", false), classOf[Int])

返回。

List(1)

只是按预期

Answer 6

最后，这个问题简化为找到基元和相应的装箱类型之间的映射。
也许可以从 scala.reflect.Inspiration （未包含在 2.8.0 的最终版本中）获得帮助，特别是 getAnyValClass 函数（此处稍作编辑

def getAnyValClass(x: Any): java.lang.Class[_] = x match {
  case _: Byte    => classOf[Byte]
  case _: Short   => classOf[Short]
  case _: Int     => classOf[Int]
  case _: Long    => classOf[Long]
  case _: Float   => classOf[Float]
  case _: Double  => classOf[Double]
  case _: Char    => classOf[Char]
  case _: Boolean => classOf[Boolean]
  case _: Unit    => classOf[Unit]
  case x@_        => x.asInstanceOf[AnyRef].getClass
}

）过滤器的功能很简单

def filterByClass[T: Manifest](l:List[Any]) = {
  l filter (getAnyValClass(_) == manifest[T].erasure)
}

，调用如下：

filterByClass[Int](List(1,"one",true))