如何使用Scala的ClassTag

最新推荐文章于 2024-09-11 08:28:10 发布
最新推荐文章于 2024-09-11 08:28:10 发布
阅读量3k 收藏 7
点赞数 1
文章标签： scala 大数据 java
原文链接：http://www.cnblogs.com/kaiux/p/11050643.html
版权

Scala官方文档中对于ClassTag的定义如下：

ClassTag[T]保存着在运行时被JVM擦除的类型T的信息。当我们在运行时想获得被实例化的Array的类型信息的时候，这个特性会比较有用。

下面请看一个具体的场景：

场景

假定有一个Map[String, Any]，给定一个指定的key，我们需要检查Map中是否存在该key对应的value，如果存在，则优雅地返回这个值。看起来很简单，下面让我们来实现它，并且逐渐理解ClassTag。

解决方案一

我们的第一次尝试如下所示：

def main(args: Array[String]): Unit = {
    class Animal
    val myMap: collection.Map[String, Any] = Map("Number" -> 1, "Greeting" -> "Hello World",
      "Animal" -> new Animal)
    /* 下面注释的代码将会不通过编译
     * Any不能被当时Int使用
     */
    //val number:Int = myMap("Number")
    //println("number is " + number)
    //使用类型转换，可以通过编译
    val number: Int = myMap("Number").asInstanceOf[Int]
    println("number  is " + number)
    //下面的代码将会抛出ClassCastException
    val greeting: String = myMap("Number").asInstanceOf[String]
  }

运行结果如下：

number  is 1
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    at learnscala.Test$.main(Test.scala:25)
    at learnscala.Test.main(Test.scala)

上面的代码有几个很显然的问题：

首先，当我们把Any直接当成Int来使用的时候，编译器是不会通过的：

// 这将不会通过编译
val number:Int = myMap("Number")

编译器看起来没有什么错误，但是问题在于，我们没有办法使用Map中值的具体类型。换句话说，如果我们只是把值的类型设置成Any我们没办法受益于Scala提供的类型系统，所以我们需要修改代码。

为了通过编译，我们使用了如下的类型转换把获取的值变成了Int类型：

val number:Int = myMap("Number").asInstanceOf[Int]

这种做法虽然能有效果，但是当我们尝试转换一个不相关的类型的时候，asInstanceOf会抛出一个ClassCastException异常。

所以下面这行代码，会在运行时抛出异常，因为我们试图转换一个Int值为String。

val greeting:String = myMap("Number").asInstanceOf[String]

我们又引入了一个新的问题。

就算我们使用Map的get()方法，编译器还是不会通过，因为Option[Any]也没有办法当成Option[Int]来使用：

//下面的代码将不会通过编译
val number:Option[Int] = myMap.get("Number")

你可能会想什么谁的代码里面会使用Map[String, Any]，这显然不是一个好的设计。但是我们先忽略这一点，并假设这个结构确实存在，下面我们回到这个问题。

使用asInstanceOf显然也不是一个好的方案，处理ClassCastException的办法之一是使用try/catch，但是这个方案并不是一个可靠并且优雅的方案，所以我们并不会采用。

解决方案二

class Animal {
  override def toString = "I am Animal"
}

// getValueFromMap for the Int, String and Animal
def getValueFromMapForInt(key: String, dataMap: collection.Map[String, Any]):Option[Int] =
  dataMap.get(key) match {
    case Some(value: Int) => Some(value)
    case _ => None
  }

def getValueFromMapForString(key: String, dataMap: collection.Map[String, Any]: Option[String] =
  dataMap.get(key) match {
    case Some(value: String) => Some(value)
    case _ => None
  }

def getValueFromMapForAnimal(key: String, dataMap: collection.Map[String, Any]: Option[Animal] =
  dataMap.get(key) match {
    case Some(value: Animal) => Some(value)
    case _ => None
  }

def main(args: Array[String]): Unit = {
  val myMap: collection.Map[String, Any] = Map("Number" -> 1, "Greeting" -> "Hello World", "Animal" -> new Animal)
  // returns Some(1)
  val number1: Option[Int] = getValueFromMapForInt("Number", myMap)
  println("number is " + number1)
  // returns None
  val numberNotExists: Option[Int] = getValueFromMapForInt("Number2", myMap)
  println("number is " + numberNotExists)
  println
  // returns Some(Hello World)
  val greeting: Option[String] = getValueFromMapForString("Greeting", myMap)
  println("greeting is " + greeting)
  // returns None
  val greetingDoesNotExists: Option[String] = getValueFromMapForString("Greeting1", myMap)
  println("greeting is " + greetingDoesNotExists)
  println()
  // returns Some[Animal]
  val animal: Option[Animal] = getValueFromMapForAnimal("Animal", myMap)
  println("Animal is " + animal)
  // returns None
  val animalDoesNotExist: Option[Animal] = getValueFromMapForAnimal("Animal1", myMap)
  println("Animal is " + animalDoesNotExist)
}

运行结果如下：

number is Some(1)
number is None

greeting is Some(Hello World)
greeting is None

Animal is Some(I am Animal)
Animal is None

现在我们使用getValueFromMapForXXX方法来获取Map中XXX类型的值，从而避免了ClassCastException。

虽然解决了之前的问题，但是现在的这个解决方案任然不够好，因为，当我们增加一个新的类型的时候，就要提供一个新的getValueFromMapForXXX方法。

解决方案三

我们尝试使用类型参数来解决之前方案中getValueFromMapForXXX方法的可扩展性不足的问题。

def getValueFromMap[T](key: String, dataMap: collection.Map[String, Any]): Option[T] =
  dataMap.get(key) match {
    case Some(value: T) => Some(value)
    case _ => None
  }

现在我们只有一个getValueFromMap[T]的方法，它的参数和之前的版本一样，但是现在需要传入一个类型参数T。

def getValueFromMap[T](key: String, dataMap: collection.Map[String, Any]): Option[T] =
  dataMap.get(key) match {
    case Some(value: T) => Some(value)
    case _ => None
  }

def main(args: Array[String]): Unit = {
  class Animal {
    override def toString = "I am Animal"
  }
  val myMap: collection.Map[String, Any] = Map("Number" -> 1, "Greeting" -> "Hello World",
    "Animal" -> new Animal)
  // returns Some(1)
  val number1: Option[Int] = getValueFromMap[Int]("Number", myMap)
  println("number is " + number1)
  // returns None
  val numberNotExists: Option[Int] = getValueFromMap[Int]("Number2", myMap)
  println("number is " + numberNotExists)
  println
  // returns Some(Hello World)
  val greeting: Option[String] = getValueFromMap[String]("Greeting", myMap)
  println("greeting is " + greeting)
  // returns None
  val greetingDoesNotExists: Option[String] = getValueFromMap[String]("Greeting1", myMap)
  println("greeting is " + greetingDoesNotExists)
  println()
  // returns Some[Animal]
  val animal: Option[Animal] = getValueFromMap[Animal]("Animal", myMap)
  println("Animal is " + animal)
  // returns None
  val animalDoesNotExist: Option[Animal] = getValueFromMap[Animal]("Animal1", myMap)
  println("Animal is " + animalDoesNotExist)
  println
  // 注意，这里开始出现问题了
  // 现在编译器不会报错，因为所有的都发生在运行时
  // 即使getValueFromMap 返回的是 Option[String]
  val greetingInt: Option[Int] = getValueFromMap[Int]("Greeting", myMap)
  // 输出 Some(Hello World)
  println("greetingInt is " + greetingInt)
  // 这里会抛出 ClassCastException
  val somevalue = greetingInt.map((x) => x + 5)
  // 下面的不会打印
  println(somevalue)
}

运行结果如下：

number is Some(1)
number is None

greeting is Some(Hello World)
greeting is None

Animal is Some(I am Animal)
Animal is None

greetingInt is Some(Hello World)
Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
    at scala.runtime.BoxesRunTime.unboxToInt(BoxesRunTime.java:103)
    at scala.runtime.java8.JFunction1$mcII$sp.apply(JFunction1$mcII$sp.java:23)
    at scala.Option.map(Option.scala:163)
    at learnscala.Test$.main(Test.scala:63)
    at learnscala.Test.main(Test.scala)

现在，我们所需要做的就是调用getValueFromMap[T]方法，并且传递我们期待的类型和key，这样Map就可以返回我们需要的value。假如我们需要获取一个key为Number的Int类型的值，我们只需要这样做就可以了：

val number1:Option[Int] = getValueFromMap[Int]("Number", myMap)

到现在为止，我们看起来有了一个可靠的解决方案，因为我们只有一个getValeFromMap方法，并且我们也没有编译错误或者因为调用asInstanceOf不当而抛出的运行时ClassCastException异常。

在解决方案三中，我们解决了如下的几个问题：

  1. 用户需要更加了解他正在处理的类型，以减少不必要的运行时异常。
  2. 不需要asInstanceOf方法，如果key找到了，那么我们返回对应的Some[value]，否则，返回None。
  3. 可扩展性更好。

到现在为止看起来还好，但是就像上面代码中所展示的，当用户不小心使用了错误的类型时，还是会有错误发生。

下面的代码虽然可以正常工作，但是并不符合逻辑：

//尝试转换 Option[String] 为 Option[Int]
val greetingInt:Option[Int] = getValueFromMap[Int]("Greeting", myMap)

Map中key为Greeting的value值为String类型，但是我们把它赋值给Option[Int]。惊人的是，下面的代码可以正常工作：

// prints Some(Hello World)
println("greetingInt is " + greetingInt)

但是当我们做一个Int操作的时候，会抛出异常。

如下所示的代码，会抛出ClassCaseException：

// 这行代码会抛出 ClassCastException 异常
val somevalue = greetingInt.map((x) => x + 5)
// 下面这行代码不会被打印
println(somevalue)

是不是getValueFromMap[T]需要捕获这个异常呢，我们的方法有问题吗？让我们继续看一下这个方法：

def getValueFromMap[T](key:String, dataMap: collection.Map[String, Any]): Option[T] =
    dataMap.get(key) match {
      case Some(value:T) => Some(value)
      case _ => None
    }

方法看起来是好的，我们所做的就是调用get(key)方法，并且检查value是不是T类型的，如果是，并且存在这个value，那么返回Some(value: T),否则返回None。

所以，在上面的例子中，key为Greeting的value类型为Int,它应该检查Some(value: Int)是否是符合，显然，它应该返回None,因为key为Greeting的value的值为：Hello World，这是一个String而不是Int。但是我们使用了一个Int去接收。

问题在于，为什么下面这行代码没有捕捉到异常：

case Some(value:T) => Some(value)

运行时只会检查key有没有对应的value，而不会检查value是否是我们传递的T类型。因为运行时不包含我们传递的任何类型信息，在运行时，T已经被擦除不存在了。在JVM中被称为类型擦除。

所以我们最好可以保证，我们传递的类型T在运行时可以存在，去帮助运行时实现一些逻辑。下面我们引入ClassTag。

我们需要做的就是传递一个隐式的ClassTag[T]参数，如果我们需要获取Map中Int类型的value时，我们需要传递一个隐式的ClassTag[Int]参数。然后，当我们调用这个方法的时候，我们可以不传递隐式参数（参考Scala隐式转换），编译器会自动为我们提供。

所以现在的getValuleFromMap看起来是下面这样的：

def getValueFromMap[T](key:String, dataMap: collection.Map[String, Any])(implicit t:ClassTag[T]): Option[T] = {
    dataMap.get(key) match {
      case Some(value: T) => Some(value)
      case _ => None
    }
  }

上面的方法也可以写成这样，效果是以一样的，但是看起来优雅一些：

def getValueFromMap[T : ClassTag](key:String, dataMap: collection.Map[String, Any]): Option[T] = {
    dataMap.get(key) match {
      case Some(value: T) => Some(value)
      case _ => None
    }

方法调用不需要做任何改变，因为编译器会为我们提供隐式的ClassTag[T]参数。

最终的方案

// getValueFromMap
def getValueFromMap[T: ClassTag](key: String, dataMap: collection.Map[String, Any]): Option[T] = {
  dataMap.get(key) match {
    case Some(value: T) => Some(value)
    case _ => None
  }
}

def main(args: Array[String]): Unit = {
  class Animal {
    override def toString = "I am Animal"
  }
  val myMap: collection.Map[String, Any] = Map("Number" -> 1, "Greeting" -> "Hello World",
    "Animal" -> new Animal)
  // returns Some(1)
  val number1: Option[Int] = getValueFromMap[Int]("Number", myMap)
  println("number is " + number1)
  // returns None
  val numberNotExists: Option[Int] = getValueFromMap[Int]("Number2", myMap)
  println("number is " + numberNotExists)
  println
  // returns Some(Hello World)
  val greeting: Option[String] = getValueFromMap[String]("Greeting", myMap)
  println("greeting is " + greeting)
  // returns None
  val greetingDoesNotExists: Option[String] = getValueFromMap[String]("Greeting1", myMap)
  println("greeting is " + greetingDoesNotExists)
  println()
  // returns Some[Animal]
  val animal: Option[Animal] = getValueFromMap[Animal]("Animal", myMap)
  println("Animal is " + animal)
  // returns None
  val animalDoesNotExist: Option[Animal] = getValueFromMap[Animal]("Animal1", myMap)
  println("Animal is " + animalDoesNotExist)
  println
  // 现在这行代码没有问题，我们会得到None
  val greetingInt: Option[Int] = getValueFromMap[Int]("Greeting", myMap)
  // prints None
  println("greetingInt is " + greetingInt)
  // 没有 ClassCastException 并且返回 None
  val somevalue = greetingInt.map((x) => x + 5)
  // print None
  println(somevalue)
  println
  // other map with list
  val someMap = Map("Number" -> 1, "Greeting" -> "Hello World",
    "Animal" -> new Animal, "goodList" -> List("good", "better", "best"))
  // gets the list from map
  val goodList: Option[List[String]] = getValueFromMap[List[String]]("goodList", someMap)
  // prints the list
  println(goodList)
  println
  println("Now let us try to get bad list")
  // tries to get bad list from the map
  val badListNotExists: Option[List[String]] = getValueFromMap[List[String]]("badList", someMap)
  // prints None
  println(badListNotExists)
}

代码的输出如下：

number is Some(1)
number is None

greeting is Some(Hello World)
greeting is None

Animal is Some(I am Animal)
Animal is None

greetingInt is None
None

Some(List(good, better, best))

Now let us try to get bad list
None

现在，所有的问题都解决了，感谢Scala提供的ClassTag，帮我们在运行时获得我们传递的类型参数的信息。

结论

ClassTag对于我们在运行时获得类型参数T的信息是至关重要的，在多数情况下，它会提供许多便利。然而，它也有一些局限性，我们只能从ClassTag获取更高类型的信息，而不是参数类型更高的信息，这听起来有点绕，让我们看下面的例子。

如果我们使用下面的代码：

val goodList:Option[List[Int]] = getValueFromMap[List[Int]]("goodList", someMap)
    // prints the list
    println(goodList)

替换：

val goodList:Option[List[String]] = getValueFromMap[List[String]]("goodList", someMap)
    // prints the list
    println(goodList)

它仍然能正常工作，因为ClassTag仅仅在运行时提供更高的类型信息（List）不是参数类型的信息（Int、String）。这就是即使我们使用getValueFromMap[List[Int]]去接受key为goodList的value还能正常工作的原因。但是在有些情况下，我们需要在运行时获得参数的类型信息，这时候我们就需要使用TypeTag。

参考

How to Use the Scala ClassTag

转载于:https://www.cnblogs.com/kaiux/p/11050643.html

weixin_34068198
关注
46.ClassTag 、Manifest、ClassManifest、TypeTag代码实战及其在Spark中的应用源码解析
KongMingJue的博客
09-21 526
一、ClassTag 、Manifest、ClassManifest、TypeTag代码实战 package ce.scala.zhong object Multiple_Bounds_46 { def main(args: Array[String]): Unit = { //常见写法（推荐） def arrayMake[T : Manifest](first :
Scala关于ClassTag 、Manifest、ClassManifest、TypeTag的使用
吟啸徐行
08-10 5488
Scala中ClassTag 、Manifest、ClassManifest、TypeTag是描述运行时类型信息的，由于Scala是运行在JVM之上的，所以首选需要从JVM说起。JVM中的泛型并不会保存泛型的，我们一般在Java开始时候涉及到的泛型都是源码级别的，当我们反编译打开编译之后的class文件会发现并不存在泛型信息。Scala为了在运行时能够获取到泛型信息，就推出了如上关键字。
ScalaTags使用指南
最新发布
gitblog_00187的博客
09-11 880
ScalaTags使用指南 scalatags 项目地址: https://gitcode.com/gh_mirrors/sca/scalatags 1. 项目介绍 Sca...
关于Scala的ClassTag
ZhuZhuDrinkMilk
02-08 433
https://zhuanlan.zhihu.com/p/69792401
ClassTag
幼稚的小龙龙
11-28 405
源码中的解释，在泛型中，type T是被擦除的。这个是非常有用的，在我们构建数组的时候，但是数组的类型我们也不知道，编译的时候不知道，但是运行的时候要知道，ClassTag只包含实际运行时的类的类型。 ClassTag会帮我们存储T的信息，如下面，传入1,2根据类型推到可以指定T是Int类型，这时候ClassTag就可以把Int类型这个信息传递给编译器。ClassTag运行时指定在编译的时候无法指...
Scala中ClassTag 、Manifest、ClassManifest、TypeTag的关系
csdn5215的博客
12-25 790
在Scala中应用了大量的数组，按照Scala的语法来说是不能创建泛型数组，因为Scala编译时必须要确定它的类型，否则编译都不能通过，但是Scala中引入了Manifest，Manifest可以有效解决这个问题 如下图： 注：如上图中： 当调用方法传递参数执行时，ClassTag会把参数类型记住，其实ClassTa
map写法 scala语言_使用Scala语言进行编程
weixin_39821605的博客
12-20 266
Scala和Kotlin、Clojure等一样是一种jvm语言，传说其复杂度可与C++一较高下。用下来感觉并不舒服，例如其中的implicit特性，能够减少很多代码的冗余，但另一方面，又会导致代码对新手而言的可读性变差。这篇文章拆分自我从前的文章《使用Scala进行Spark-GraphX编程》。括号通常，小括号()表示表达式和函数调用，大括号{}表示代码块。例如在.map({})中的大括号即表示...
scala-newtype：Scala的NewType，没有运行时开销
02-05
它们通常用`scala.util.Tagged`或`shapeless.Tag`来实现，可以提供类型信息，特别是在类型擦除后。`Tagged Types`在编译时提供类型信息，但不会阻止不同标记类型的值之间的相互转换。例如： ```scala import scala....
[scala-spark]2. Scala运行原理与源码查看
沈春旭的博客
09-22 714
运行原理 韩顺平 查看源码 package com.lineshen.chapter1 object lookSourceCode { def main(args: Array[String]): Unit = { val arr = new Array[String](10) for (item <- arr){ println("item ...
scala 连接oracle_scala使用jdbc连接oracle数据库
weixin_32617915的博客
12-31 335
使用JdbcRDD方法：jdbcRDD定义：*AnRDDthatexecutesanSQLqueryonaJDBCconnectionandreadsresults.*Forusageexample,seetestcaseJdbcRDDSuite.**@paramgetConnectionafunctionthatreturnsanopen...
大数据系列修炼-Scala课程46
什么最重要？算法！！
09-24 1590
大数据系列修炼-Scala课程46核心内容: 1、scala中ClassTag、Manifest、ClassManifest、TypeTag的具体应用1、scala中ClassTag、Manifest、ClassManifest、TypeTag的具体应用1>泛型T在编写与编译的时候不能确定出具体的数据类型，但是虚拟机在运行的时候必须要指定出T具体的数据类型，因为我们的scala是 运行在Java
Scala中Manifest、ClassTag、TypeTag的学习
遥望......
04-24 2010
Manifest介绍 Manifest是scala2.8引入的一个特质，用于编译器在运行时也能获取泛型类型的信息。 在JVM上，泛型参数类型T在运行时是被“擦拭”掉的，编译器把T当作Object来对待， 所以T的具体信息是无法得到的；为了使得在运行时得到T的信息， scala需要额外通过Manifest来存储T的信息，并作为参数用在方法的运行时上下文 def test[T] (x:T, m:M...
解决了我对scala中ClassTag的困惑
热门推荐
mark's technic world
12-23 1万+
1> Mainfest上下文界定 1. 在Scala中数组必须是有类型的，如果直接是泛型的话将会报错，这时候引入了Manifest上下文界定，需要一个Mainfest[T]对象，而mainifest[T]有一个隐式值， 2. 如果调用makePair(1,2)，编译器将定位到隐式的Manifst[Int]并实际上调用makePair(2,3)(intManifest),该方法调用的就是n
ClassTag、Manifest
sinat_27976951的博客
10-18 291
》Manifest Manifest是scala2.8引入的一个特质，用于编译器在运行时也能获取泛型类型的信息。 在JVM上，泛型参数类型T在运行时是被“擦拭”掉的，编译器把T当作Object来对待， 所以T的具体信息是无法得到的；为了使得在运行时得到T的信息， scala需要额外通过Manifest来存储T的信息，并作为参数用在方法的运行时上下文。
关于jvm范型和scala implicit隐式参数以及classTag[T] typeTag[T]的一点思考
monkeyboy_tech的博客
12-14 320
T: Comparator]，它主要做了两件事：第一，引入了一个参数类型 T；在上面说到对于java语言来说，会在编译器期间擦除掉类型，但是对于scala来说，我们在编译器阶段是可以保存类型T的,这就是接下来说的。看到我们居然把可以范型为T（也就是object）的类型的值，赋值给String类型的变量，这难道是编译器没有进行类型擦除么？，其中aaa是String类型的变量，这样编译器在编译的时候，就会做一层强制转换。这一行表明编译器确实进行了类型擦数，因为能偶看到调用的是object类型的方法。
Java创建ClassTag的方法
虾哔哔的博客
01-17 690
Java创建ClassTag的方法，我能找到的有三个方法。其中第三种方法，只要需要classtag的地方都可以直接用，参数都不需要。 1：ClassManifestFactory.classType( String.class )。 2：ClassTag$.MODULE$.apply( String.class )。 3：JavaSparkContext$.MODULE$.fakeClass...
Type与Class、ClassTag与TypeTag
hellojoy的博客
07-16 1984
Scala中获取Class的方式：scala&gt; class A defined class A scala&gt; val a = new A a: A = A@17a1e4ca scala&gt; a.getClass res10: Class[_ &lt;: A] = class A scala&gt; classOf[A] res11: Class[A] = class A   ...
探索Scala类型参数：泛型、限定与Ordering应用
2.5 **ClassTag上下文界定**: `ClassTag`是Scala提供的类型标记，用于获取类型的信息，如类名和类的构造器。在某些情况下，比如类型擦除或反射时，ClassTag非常有用。 2.6 **类型下界限定**: 类型下界限定与上界...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值