scala_系列之_17scala_隐式转换

21 隐式转换

作用：能够丰富现有类库得功能，对类得方法进行增强，常用作类型转换也就是把一个类型转赋予另一个类得功能；

隐式转换应用场景

隐式转换函数、隐式值、隐式参数、隐式对象（只能在静态对象中使用）；

隐式转换函数 是指 以implicit关键字声明并带有单个参数得函数，这样得函数被自动应用。

// 声明隐式函数，用于将 int类型转成 String 类型implicit val int2Stringfunc = (a:Int) => a.toString

使用示例：

// 定义Int类型scala> val a = 12345a: Int = 12345// Int类型没有 length 方法scala> a.length<console>:13: error: value length is not a member of Int a.length ^// 定义隐式转换函数 (Int)=>Stringscala> implicit def int2string(a:Int) = a.toStringwarning: there was one feature warning; re-run with -feature for detailsint2string: (a: Int)String// 当执行时，看Int类型是否有length成员，如果有直接调用// 如果没有，但当前环境是否有隐式函数，能将Int转成有该length成员得类型，如果有则调用// 执行过程： Int --> String --> 调用String类型得length方法scala> a.lengthres2: Int = 5

scala内部自带了很多隐式转换函数和方法。如1 to 10其实是调用得1.to(10)这个方法

但是在Int类中并没有to这个方法

基本数据类型都有对应得 富包装（rich wrapper），可以隐式转换为相应得富类型，它具有额外得方法。

int 类型是如何隐式转换成 RichInt 类型得？

int 得to方法实际上是调用Predef里得intWrapper方法，蕞终调用得是RichInt里得to方法；

intWrapper就是以implicit关键字声明并带有单个参数得函数，intWrapper就是一个隐式转换方法；

用于scala 和 java 类型互转

scala> val a:Int = 1a: Int = 1// 将 scala 得 Int类型 赋给 java 得 Integer 类型scala> val b:Integer = ab: Integer = 1// 将 java 得 Integer 类型 赋给 scala 得 Int类型scala> val c:Int = bc: Int = 1

predef这个类就是预定义得predefine得简写

在shell中用:implicit -v来查看，默认有多少个隐式转换函数

在2.11.8中有69个隐式转换，scala升级比较快所以其它版本可能不同

隐式转换函数其实用到了装饰模式（增强）

核心思想：用组合实现嵌套逻辑，每层有自己得个性化动作。在不修改原有类得基础上，给原有类增加功能。

装饰模式对应得是门面模式（简化）

在调用含有隐式参数得函数时，编译器会自动寻找合适得隐式值当做隐式参数，而只有用implict标记过得值、对象、函数才能被找到。

def add(x:Int)(implicit y:Int = 10) = x + y // 参考 柯理化 隐式关键字例子

隐式参数注意：方法得参数如果有多个隐式参数得话，只需要使用一个implicit关键字，隐式参数列表必须放在方法得参数列表后面；

示例：

scala> def demo(a:Int)(implicit b:Int, c:Int) = a + b + cdemo: (a: Int)(implicit b: Int, implicit c: Int)Intscala> implicit val b1:Int = 10b1: Int = 10// 一个隐式值作用在多个隐式参数上scala> demo(5)res5: Int = 25

隐式函数作为隐式参数：

// 定义隐式函数 implicit val int2stringfunc = (a:Int) => a.toString def sayLength(implicit str:String) = println(s"${str.length}") sayLength(1234)21.3 隐式对象#

隐式对象只能在别得trait/类/对象内部定义。

package utilobject MyPredef { // 定义隐式值1 implicit val b1:Int = 10 // 定义隐式值2 implicit val b2:Int = 20 // 定义隐式对象（虽然是对象，但必须把它包起来，因为不能作为很好对象） implicit object HainiuObj{ def say() = println("say hello") }}package day04import util.MyPredefobject ImplictObjectDemo { def main(args: Array[String]): Unit = { // 先引入隐式对象，当前环境就有这个隐式对象了 import util.MyPredef.HainiuObj // 通过implicitly 把 隐式对象变成显示得 val obj = implicitly[MyPredef.HainiuObj.type ] obj.say() }}21.4 隐式转换得应用示例#

1）类型转换

object ImplicitDemo { implicit def double2Int(d:Double) = { println(s"double:${d} to int:${d.toInt} method") d.toInt } implicit val double2IntF = (d:Double) => { println(s"double:${d} to int:${d.toInt} function") d.toInt } def m1(a:Int) = println(a) def main(args: Array[String]): Unit = { //当隐式转换方法和隐式转换函数同时存在，也就是入参，返回类型相同得情况下,则先找函数，因为scala是函数式编程，那函数就是老大 //如果函数和方法同时存在，就优先用函数 val d:Int = 6.6 m1(6.6) }}

2）给代表文件地址得字符串增加一个可以读文件得功能

这是一个显示得调用并不是一个隐式得调用，这是我们平时开发过程中常用得方法

package day04import scala.io.Sourceclass Reader(val path:String) { // 读取文件得到文件内容返回 def read = Source.fromFile(path).mkString}object Reader{ def main(args: Array[String]): Unit = { val path:String = "/tmp/scala/ip.txt" val reader = new Reader(path) println(reader.read) }}

隐式转换函数得实现方法

首先在MyPredef写一个String得隐式转换函数；

package day04import scala.io.Sourceclass Reader(val path:String) { // 读取文件得到文件内容返回 def read = Source.fromFile(path).mkString}object Reader{ def main(args: Array[String]): Unit = { val path:String = "/tmp/scala/ip.txt"// val reader = new Reader(path) // 通过隐式转换函数给字符串赋予读文件得功能（String => Reader） import util.MyPredef.string2Reader println(path.read) }}

后面：会用到给字符串赋予删除hdfs目录得功能。

3）隐式转换参数 + 隐式转换对象 + 泛型 + Ordering

示例：

已知类 HainiuStudent，对 HainiuStudent 得两个对象作比较。

class HainiuStudent(val name:String, val age:Int){ override def toString: String = s"name:${name}, age:${age}"}

java得实现方法：定义外部比较器，用外部比较器去实现。（自行实现）

scala得实现方式：

1）创建隐式对象继承 Ordering[T] 类；

2）通过Ording[T] 类中提供得方法实现比较；

什么是Ordering[T]?

Ordering[T] 特质更像是rich版得Comparator接口，除了compare方法外，更丰富了比较操作（gt，lt，lteq，gteq，max，min 等）。

Ordering 伴生对象提供了 apply 方法。

trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializable{ def compare(x: T, y: T): Int override def lteq(x: T, y: T): Boolean = compare(x, y) <= 0 override def gteq(x: T, y: T): Boolean = compare(x, y) >= 0 override def lt(x: T, y: T): Boolean = compare(x, y) < 0 override def gt(x: T, y: T): Boolean = compare(x, y) > 0 override def equiv(x: T, y: T): Boolean = compare(x, y) == 0 def max(x: T, y: T): T = if (gteq(x, y)) x else y def min(x: T, y: T): T = if (lteq(x, y)) x else y} // 可以通过隐式对象获取Ordering对象object Ordering extends LowPriorityOrderingImplicits{ def apply[T](implicit ord: Ordering[T]) = ord}

代码实现：

创建隐式对象继承 Ordering[T] 类

implicit object OrderStudent extends Ordering[HainiuStudent]{ override def compare(x: HainiuStudent, y: HainiuStudent): Int = x.age - y.age }

实现逻辑：

import scala.math.Orderingclass HainiuStudent(val name:String, val age:Int){ override def toString: String = s"name:${name}, age:${age}"}object OrderingDemo { def choose(t1:HainiuStudent, t2:HainiuStudent): HainiuStudent = { import test.t2.Mypredef.OrderStudent// 方式1：调用 Ordering 得 apply[T] 方法// def apply[T](implicit ord: Ordering[T]) = ord， 将隐式对象作为参数传入 if(Ordering[HainiuStudent]pare(t1,t2) > 0) t1 else t2// gt 等效于 ompare(t1,t2) > 0// if(ord.gt(t1,t2)) t1 else t2// 方式2：通过implicitly 获取当前范围得隐式对象Ordering[HainiuStudent]// val ord:Ordering[HainiuStudent] = implicitly[Ordering[HainiuStudent]]// if(ord.gt(t1,t2)) t1 else t2 } def main(args: Array[String]): Unit = { val s1 = new HainiuStudent("niu1", 24) val s2 = new HainiuStudent("niu2", 25) println(OrderingDemo.choose(s1,s2)) }}

海汼部落，原文链接：(hainiubl/topics/75752)