Scala：如何匹配Scala.Long和java.lang.Long的模式

我需要在课堂上做一个模式匹配。问题是，我有一些问题匹配长

我需要以相同的方式处理scala.Long和java.lang.Long，但是为什么在这种情况下我需要声明它们呢

以下是一个例子：

  def test(typ: Class[_]) {
    typ match {
      case q if q == classOf[Long] => println("scala long...")
    }
  }

  val scalaLongField: java.reflect.Field = ......
  val javaLongField: java.reflect.Field = ......
  test(scalaLongField.getType) // prints "scala long..."
  test(javaLongField.getType) // scala.MatchError: class java.lang.Long (of class java.lang.Class)

---

有没有一种方法可以在不使用实例而只使用类的情况下处理它们？

它应该可以立即工作：

object LongTest {
  def test(value: Any): Boolean = value match {
    case l: Long => true
    case _ => false
  }

  def run() {
    println(test(1L))
    println(test(new java.lang.Long(1L)))
  }
}

LongTest.run()  // true and true

---

我不清楚您是否希望匹配类而不是实例。我不确定我是否明白你到底想要什么。像这样

object LongTest {
  def test(clazz: Class[_]): Boolean = 
    clazz == classOf[Long] || clazz == classOf[java.lang.Long]

  def run() {
    println(test(1L.getClass))
    println(test(new java.lang.Long(1L).getClass))
  }
}

LongTest.run()  // true and true

或作为模式匹配：

  def test(clazz: Class[_]): Boolean = clazz match {
    case q if q == classOf[Long] || q == classOf[java.lang.Long] => true
    case _ => false
  }

---

原因是

java.lang.Long

和

Long

是不同的类。在Java中，

Java.lang.Long.class

和

Long.TYPE

之间存在差异。类似地，在Scala中，

classOf[Long]

和

classOf[java.lang.Long]

是不同的

如果要在类上进行模式匹配，可以为该类创建帮助器

方法，方法如下：

object ScalaLong {
  // Internal helper:
  private def matchClass[T](c: Class[_], as: Class[T]): Option[Class[T]] =
    if (as.isAssignableFrom(c)) Some(as)
    else None;

  // Matches wrapped Long classes.
  object LongObject {
    def unapply(c: Class[_]): Option[Class[java.lang.Long]] =
      matchClass(c, classOf[java.lang.Long]);
  }
  // Matches primitive long classes.
  object LongPrim {
    def unapply(c: Class[_]): Option[Class[Long]] =
      matchClass(c, classOf[Long]);
  }

  // -- Test:

  def check(clz: Class[_]) =
    clz match {
      case LongPrim(c)   => println("Long primitive: " + c);
      case LongObject(c) => println("Long object: " + c);
      case _             => println("Other: " + clz);
    }


  class Example {
    val l1: scala.Long = 1L;
    val l2: java.lang.Long = 1L;
    val l3: java.lang.Integer = 1;
  }

  def main(argv: Array[String]) {
    for(name <- Seq("l1", "l2", "l3"))
      check(classOf[Example].getMethod(name).getReturnType());
  }
}

对象缩放{
//内部助理：
私有def matchClass[T]（c:Class[_]，as:Class[T]）：选项[Class[T]]=
如果（as.isAssignableFrom（c））某些（as）
其他的都没有；
//匹配长类。
对象长对象{
def unapply（c:Class[]）：选项[Class[java.lang.Long]]=
matchClass（c，classOf[java.lang.Long]）；
}
//匹配基元长类。
对象LongPrim{
取消应用def（c:Class[)]：选项[Class[Long]]=
匹配类（c，classOf[Long]）；
}
//--测试：
def检查（clz:Class[3;]）=
clz匹配{
案例LongPrim（c）=>println（“长原语：+c”）；
案例长对象（c）=>println（“长对象：+c”）；
案例=>println（“其他：+clz）；
}
课例{
val l1:scala.Long=1L；
val l2:java.lang.Long=1L；
val l3:java.lang.Integer=1；
}
def main（argv:Array[String]）{
for（如果我有值，请说出名称！当我只有类时，我需要这样做，就像我在问题中说的：“有没有一种方法可以在没有实例而只有类的情况下处理它们？”@mklemenz您可以很好地将示例限制在您想要的范围内。大多数（2/3）在所有示例方法中，只有一个方法具有该值，而只有一个方法具有该类。