스칼라 : 패턴 일치 방법 scala.Long 및 java.lang.Long

Question

클래스에서 패턴 일치를 수행해야합니다. 문제는 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) 

인스턴스 있었으나 결국 수업을하지 않고 그들에게 동일하게 처리 할 수있는 방법이 있나요 : 여기

은 예입니다? 그것은 바로 작동합니다

Answer 1

이유는 java.lang.Long 및 Long가 다른 클래스 점이다. Java에서는 java.lang.Long.class과 Long.TYPE 사이에 차이가 있습니다. 마찬가지로 Scala에서는 classOf[Long]과 classOf[java.lang.Long]이 다릅니다. 당신이 클래스에 대한 패턴 일치를 원하는 경우

, 당신은 도우미에게 그것에 대해 unapply 방법을 만들 수 있습니다

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()); 
    } 
} 

일반적으로, 별도로 classOf[Long] 및 classOf[java.lang.Long]을 치료해야합니다. 아마도, 당신이 당신이 그들과 함께해야 할 것을 설명한다면, 우리는 당신의 특정 업무에 더 나은 해결책을 찾을 수있을 것입니다.

Answer 2

는 :

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 
    }