Scala Predef对象详解
Scala Predef对象
Scala程序设计 第2版 - 原版.pdf 下载：https://download.csdn.net/download/u014646662/10805074
目录：
1.Predef源码
2.类型装换
3.类型定义
4.条件检查方法
5.输入输出方法
6.其他
对人工智能感兴趣的同学，可以点击以下链接：
现在人工智能非常火爆，很多朋友都想学，但是一般的教程都是为博硕生准备的，太难看懂了。最近发现了一个非常适合小白入门的教程，不仅通俗易懂而且还很风趣幽默。所以忍不住分享一下给大家。点这里可以跳转到教程。
https://www.cbedai.net/u014646662
1 Predef源码
为了方便起见，只要你编译代码，Scala 编译器就会自动导入顶层Scala 包（名为scala）以及在java.lang 包（就像javac 的）中的定义。因此，许多常见的Java 和Scala 类型都可以不经过明显地导入或提供完整的名称就可以使用。另外，编译器还导入了Predef 对象中的一些定。接下来，我们来详细了解Predef 提供的特性。需要注意的是，Scala 2.11 版本的Predef 引入了很多变化，其中大部分是不可见的。
看一看源码：
package scala
object Predef extends scala.LowPriorityImplicits with scala.DeprecatedPredef {
def classOf[T] : Predef.Class[T] = { /* compiled code */ }
type Class[T] = java.lang.Class[T]
type String = java.lang.String
type Function[-A, +B] = scala.Function1[A, B]
type Map[A, +B] = scala.collection.immutable.Map[A, B]
type Set[A] = scala.collection.immutable.Set[A]
val Map : scala.collection.immutable.Map.type = { /* compiled code */ }
val Set : scala.collection.immutable.Set.type = { /* compiled code */ }
@scala.deprecated("use `scala.reflect.ClassTag` instead", "2.10.0")
@scala.annotation.implicitNotFound("No ClassManifest available for ${T}.")
type ClassManifest[T] = scala.reflect.ClassManifest[T]
type OptManifest[T] = scala.reflect.OptManifest[T]
@scala.annotation.implicitNotFound("No Manifest available for ${T}.")
type Manifest[T] = scala.reflect.Manifest[T]
@scala.deprecated("use `scala.reflect.ClassTag` instead", "2.10.0")
val ClassManifest : scala.reflect.ClassManifestFactory.type = { /* compiled code */ }
val Manifest : scala.reflect.ManifestFactory.type = { /* compiled code */ }
val NoManifest : scala.reflect.NoManifest.type = { /* compiled code */ }
def manifest[T](implicit m : Predef.Manifest[T]) : Predef.Manifest[T] = { /* compiled code */ }
@scala.deprecated("use scala.reflect.classTag[T] instead", "2.10.0")
def classManifest[T](implicit m : Predef.ClassManifest[T]) : Predef.ClassManifest[T] = { /* compiled code */ }
def optManifest[T](implicit m : Predef.OptManifest[T]) : Predef.OptManifest[T] = { /* compiled code */ }
@scala.inline
def identity[A](x : A) : A = { /* compiled code */ }
@scala.inline
def implicitly[T](implicit e : T) : T = { /* compiled code */ }
@scala.inline
def locally[T](x : T) : T = { /* compiled code */ }
@scala.annotation.elidable(2000)
def assert(assertion : scala.Boolean) : scala.Unit = { /* compiled code */ }
@scala.inline
@scala.annotation.elidable(2000)
final def assert(assertion : scala.Boolean, message : => scala.Any) : scala.Unit = { /* compiled code */ }
@scala.annotation.elidable(2000)
def assume(assumption : scala.Boolean) : scala.Unit = { /* compiled code */ }
@scala.inline
@scala.annotation.elidable(2000)
final def assume(assumption : scala.Boolean, message : => scala.Any) : scala.Unit = { /* compiled code */ }
def require(requirement : scala.Boolean) : scala.Unit = { /* compiled code */ }
@scala.inline
final def require(requirement : scala.Boolean, message : => scala.Any) : scala.Unit = { /* compiled code */ }
def ??? : scala.Nothing = { /* compiled code */ }
@scala.deprecated("use built-in tuple syntax or Tuple2 instead", "2.11.0")
type Pair[+A, +B] = scala.Tuple2[A, B]
@scala.deprecated("use built-in tuple syntax or Tuple2 instead", "2.11.0")
object Pair extends scala.AnyRef {
def apply[A, B](x : A, y : B) : scala.Tuple2[A, B] = { /* compiled code */ }
def unapply[A, B](x : scala.Tuple2[A, B]) : scala.Option[scala.Tuple2[A, B]] = { /* compiled code */ }
}
@scala.deprecated("use built-in tuple syntax or Tuple3 instead", "2.11.0")
type Triple[+A, +B, +C] = scala.Tuple3[A, B, C]
@scala.deprecated("use built-in tuple syntax or Tuple3 instead", "2.11.0")
object Triple extends scala.AnyRef {
def apply[A, B, C](x : A, y : B, z : C) : scala.Tuple3[A, B, C] = { /* compiled code */ }
def unapply[A, B, C](x : scala.Tuple3[A, B, C]) : scala.Option[scala.Tuple3[A, B, C]] = { /* compiled code */ }
}
implicit final class ArrowAssoc[A](self : A) extends scala.AnyVal {
@scala.inline
def ->[B](y : B) : scala.Tuple2[A, B] = { /* compiled code */ }
def →[B](y : B) : scala.Tuple2[A, B] = { /* compiled code */ }
}
implicit final class Ensuring[A](self : A) extends scala.AnyVal {
def ensuring(cond : scala.Boolean) : A = { /* compiled code */ }
def ensuring(cond : scala.Boolean, msg : => scala.Any) : A = { /* compiled code */ }
def ensuring(cond : scala.Function1[A, scala.Boolean]) : A = { /* compiled code */ }
def ensuring(cond : scala.Function1[A, scala.Boolean], msg : => scala.Any) : A = { /* compiled code */ }
}
implicit final class StringFormat[A](self : A) extends scala.AnyVal {
@scala.inline
def formatted(fmtstr : Predef.String) : Predef.String = { /* compiled code */ }
}
implicit final class any2stringadd[A](self : A) extends scala.AnyVal {
def +(other : Predef.String) : Predef.String = { /* compiled code */ }
}
implicit final class RichException(self : scala.Throwable) extends scala.AnyVal {
@scala.deprecated("use Throwable#getStackTrace", "2.11.0")
def getStackTraceString : _root_.scala.Predef.String = { /* compiled code */ }
}
implicit final class SeqCharSequence(@scala.deprecated("will be made private", "2.12.0") val __sequenceOfChars : scala.collection.IndexedSeq[scala.Char]) extends java.lang.Object with java.lang.CharSequence {
def length() : scala.Int = { /* compiled code */ }
def charAt(index : scala.Int) : scala.Char = { /* compiled code */ }
def subSequence(start : scala.Int, end : scala.Int) : java.lang.CharSequence = { /* compiled code */ }
override def toString() : _root_.scala.Predef.String = { /* compiled code */ }
}
implicit final class ArrayCharSequence(@scala.deprecated("will be made private", "2.12.0") val __arrayOfChars : scala.Array[scala.Char]) extends java.lang.Object with java.lang.CharSequence {
def length() : scala.Int = { /* compiled code */ }
def charAt(index : scala.Int) : scala.Char = { /* compiled code */ }
def subSequence(start : scala.Int, end : scala.Int) : java.lang.CharSequence = { /* compiled code */ }
override def toString() : _root_.scala.Predef.String = { /* compiled code */ }
}
implicit val StringCanBuildFrom : scala.collection.generic.CanBuildFrom[Predef.String, scala.Char, Predef.String] = { /* compiled code */ }
@scala.inline
implicit def augmentString(x : Predef.String) : scala.collection.immutable.StringOps = { /* compiled code */ }
@scala.inline
implicit def unaugmentString(x : scala.collection.immutable.StringOps) : Predef.String = { /* compiled code */ }
def print(x : scala.Any) : scala.Unit = { /* compiled code */ }
def println() : scala.Unit = { /* compiled code */ }
def println(x : scala.Any) : scala.Unit = { /* compiled code */ }
def printf(text : Predef.String, xs : scala.Any*) : scala.Unit = { /* compiled code */ }
implicit def tuple2ToZippedOps[T1, T2](x : scala.Tuple2[T1, T2]) : scala.runtime.Tuple2Zipped.Ops[T1, T2] = { /* compiled code */ }
implicit def tuple3ToZippedOps[T1, T2, T3](x : scala.Tuple3[T1, T2, T3]) : scala.runtime.Tuple3Zipped.Ops[T1, T2, T3] = { /* compiled code */ }
implicit def genericArrayOps[T](xs : scala.Array[T]) : scala.collection.mutable.ArrayOps[T] = { /* compiled code */ }
implicit def booleanArrayOps(xs : scala.Array[scala.Boolean]) : scala.collection.mutable.ArrayOps.ofBoolean = { /* compiled code */ }
implicit def byteArrayOps(xs : scala.Array[scala.Byte]) : scala.collection.mutable.ArrayOps.ofByte = { /* compiled code */ }
implicit def charArrayOps(xs : scala.Array[scala.Char]) : scala.collection.mutable.ArrayOps.ofChar = { /* compiled code */ }
implicit def doubleArrayOps(xs : scala.Array[scala.Double]) : scala.collection.mutable.ArrayOps.ofDouble = { /* compiled code */ }
implicit def floatArrayOps(xs : scala.Array[scala.Float]) : scala.collection.mutable.ArrayOps.ofFloat = { /* compiled code */ }
implicit def intArrayOps(xs : scala.Array[scala.Int]) : scala.collection.mutable.ArrayOps.ofInt = { /* compiled code */ }
implicit def longArrayOps(xs : scala.Array[scala.Long]) : scala.collection.mutable.ArrayOps.ofLong = { /* compiled code */ }
implicit def refArrayOps[T <: scala.AnyRef](xs : scala.Array[T]) : scala.collection.mutable.ArrayOps.ofRef[T] = { /* compiled code */ }
implicit def shortArrayOps(xs : scala.Array[scala.Short]) : scala.collection.mutable.ArrayOps.ofShort = { /* compiled code */ }
implicit def unitArrayOps(xs : scala.Array[scala.Unit]) : scala.collection.mutable.ArrayOps.ofUnit = { /* compiled code */ }
implicit def byte2Byte(x : scala.Byte) : java.lang.Byte = { /* compiled code */ }
implicit def short2Short(x : scala.Short) : java.lang.Short = { /* compiled code */ }
implicit def char2Character(x : scala.Char) : java.lang.Character = { /* compiled code */ }
implicit def int2Integer(x : scala.Int) : java.lang.Integer = { /* compiled code */ }
implicit def long2Long(x : scala.Long) : java.lang.Long = { /* compiled code */ }
implicit def float2Float(x : scala.Float) : java.lang.Float = { /* compiled code */ }
implicit def double2Double(x : scala.Double) : java.lang.Double = { /* compiled code */ }
implicit def boolean2Boolean(x : scala.Boolean) : java.lang.Boolean = { /* compiled code */ }
implicit def Byte2byte(x : java.lang.Byte) : scala.Byte = { /* compiled code */ }
implicit def Short2short(x : java.lang.Short) : scala.Short = { /* compiled code */ }
implicit def Character2char(x : java.lang.Character) : scala.Char = { /* compiled code */ }
implicit def Integer2int(x : java.lang.Integer) : scala.Int = { /* compiled code */ }
implicit def Long2long(x : java.lang.Long) : scala.Long = { /* compiled code */ }
implicit def Float2float(x : java.lang.Float) : scala.Float = { /* compiled code */ }
implicit def Double2double(x : java.lang.Double) : scala.Double = { /* compiled code */ }
implicit def Boolean2boolean(x : java.lang.Boolean) : scala.Boolean = { /* compiled code */ }
@scala.annotation.implicitNotFound("Cannot prove that ${From} <:< ${To}.")
sealed abstract class <:<[-From, +To]() extends scala.AnyRef with scala.Function1[From, To] with scala.Serializable {
}
implicit def $conforms[A] : Predef.<:<[A, A] = { /* compiled code */ }
@scala.deprecated("use `implicitly[T <:< U]` or `identity` instead.", "2.11.0")
def conforms[A] : Predef.<:<[A, A] = { /* compiled code */ }
@scala.annotation.implicitNotFound("Cannot prove that ${From} =:= ${To}.")
sealed abstract class =:=[From, To]() extends scala.AnyRef with scala.Function1[From, To] with scala.Serializable {
}
object =:= extends scala.AnyRef with scala.Serializable {
implicit def tpEquals[A] : Predef.=:=[A, A] = { /* compiled code */ }
}
class DummyImplicit() extends scala.AnyRef {
}
object DummyImplicit extends scala.AnyRef {
implicit def dummyImplicit : Predef.DummyImplicit = { /* compiled code */ }
}
}
2 类型转换
implicit def byte2Byte(x : scala.Byte) : java.lang.Byte = { /* compiled code */ }
implicit def short2Short(x : scala.Short) : java.lang.Short = { /* compiled code */ }
implicit def char2Character(x : scala.Char) : java.lang.Character = { /* compiled code */ }
implicit def int2Integer(x : scala.Int) : java.lang.Integer = { /* compiled code */ }
implicit def long2Long(x : scala.Long) : java.lang.Long = { /* compiled code */ }
implicit def float2Float(x : scala.Float) : java.lang.Float = { /* compiled code */ }
implicit def double2Double(x : scala.Double) : java.lang.Double = { /* compiled code */ }
implicit def boolean2Boolean(x : scala.Boolean) : java.lang.Boolean = { /* compiled code */ }
implicit def Byte2byte(x : java.lang.Byte) : scala.Byte = { /* compiled code */ }
implicit def Short2short(x : java.lang.Short) : scala.Short = { /* compiled code */ }
implicit def Character2char(x : java.lang.Character) : scala.Char = { /* compiled code */ }
implicit def Integer2int(x : java.lang.Integer) : scala.Int = { /* compiled code */ }
implicit def Long2long(x : java.lang.Long) : scala.Long = { /* compiled code */ }
implicit def Float2float(x : java.lang.Float) : scala.Float = { /* compiled code */ }
implicit def Double2double(x : java.lang.Double) : scala.Double = { /* compiled code */ }
implicit def Boolean2boolean(x : java.lang.Boolean) : scala.Boolean = { /* compiled code */ }3 类型定义
Predef 定义了若干的类型及类型别名。为了鼓励使用不可变集合，Predef 为最常用的不可变集合定义了别名：
type Class[T] = java.lang.Class[T]
type String = java.lang.String
type Map[A, +B] = scala.collection.immutable.Map[A, B]
type Set[A] = scala.collection.immutable.Set[A]
type Function[-A, +B] = scala.Function1[A, B]
val Map : scala.collection.immutable.Map.type = { /* compiled code */ }
val Set : scala.collection.immutable.Set.type = { /* compiled code */ }支持类型推断的其他一些Predef 类型。
我们经常使用a -> b（或等价的a → b）这种写法：
object Test {
def main(args: Array[String]): Unit = {
val a = (1, "one")
val b = 1 -> "one"
val c = 1 → "one"
println(a) //输出：(1,one)
println(b) //输出：(1,one)
println(c) //输出：(1,one)
val map = Map("one" -> 1, "two" -> 2)
println(map) //输出：Map(one -> 1, two -> 2)
}
}事实上，Scala 根本不知道a -> b 意味着什么，因此上述方法并非没有意义。这种“字面量”格式实际上运用了方法-> 和一个特殊的Scala 特性——隐式转换。通过运用隐式转换，我们可以在任意两种类型值之间插入函数->。与此同时，由于a -> b 并不是元组的字面量语法，因此Scala 必须通过某些方式将该表达式转化为元组(a, b)。
很明显，->之所以能用，就是因为我们已经把->方法定义好了，也就是 ArrowAssoc的->方法，源码如下
implicit final class ArrowAssoc[A](self : A) extends scala.AnyVal {
@scala.inline
def ->[B](y : B) : scala.Tuple2[A, B] = { /* compiled code */ }
def →[B](y : B) : scala.Tuple2[A, B] = { /* compiled code */ }
}在此只因关键字implicit起的作用，具体执行过程：
(1) 编译器发现我们试图对String 对象执行-> 方法（例如“ one” -> 1）。
(2) 由于String 未定义-> 方法，编译器将检查当前作用域中是否存在定义了该方法的隐式转换。
(3) 编译器发现了ArrowAssoc 类。
(4) 编译器将创建ArrowAssoc 对象，并向其传入one 字符串。
(5) 之后，编译器将解析表达式中的-> 1 部分代码，并确认了整个表达式的类型与Map.apply 方法的预期类型相吻合，即两者均为pair 实例。如果希望执行隐式转换，那么在声明时必须使用implicit 关键字，能够执行隐式转换的无外乎两类：构造方法中只接受单一参数的类型或者是只接受单一参数的方法。
为了限定参数类型，Scala有了隐式证据<:<，在哪里用到了呢？
package cn.com.tengen.test.obj
object Test {
def main(args: Array[String]): Unit = {
val map = Map("one" -> 1, "two" -> 2)
println(map.toMap) //输出：Map(one -> 1, two -> 2)
val list1 = List((1,"aa"),(2,"bb"),(3,"cc"),(4,"dd"))
println(list1.toMap) //Map(1 -> aa, 2 -> bb, 3 -> cc, 4 -> dd)
val list2 = List(1,2,3,4)
println(list2.toMap) //抛出异常
}
}
@scala.annotation.implicitNotFound("Cannot prove that ${From} <:< ${To}.")
sealed abstract class <:<[-From, +To]() extends scala.AnyRef with scala.Function1[From, To] with scala.Serializable {
}package scala.collection
trait TraversableOnce[+A] extends scala.Any with scala.collection.GenTraversableOnce[A] {
...
def toMap[T, U](implicit ev: _root_.scala.Predef.<:<[A, scala.Tuple2[T, U]]): scala.collection.immutable.Map[T, U] = {
/* compiled code */
}
...
}4 条件检查方法
有时你希望断言某条件为真，希望它“快速失败”（尤其在测试时）。Predef 定义了许多有助于达到这个目的的方法。
• def assert(assertion: Boolean)
测试条件是否为真，如果不为真，抛出java.lang.AssertionError 异常。
• def assert(assertion: Boolean, message: => Any)
类似前面的assert，但增加了一个可选参数，该参数将被转为错误信息字符串。
• def assume(assertion: Boolean)
与assert 相同，但其表示当一段代码块（如方法）正确时，条件才为真。
• def assume(assertion: Boolean, message: => Any)
类似前面的assume，但增加了一个可选参数，该参数将被转为错误信息字符串。
• def require(requirement: Boolean)
与assume 相同，但根据Scaladoc，其含义是调用方是否满足某些条件，也可以表示某个实现不能得出特定的结果。
• def require(requirement: Boolean, message: => Any)
类似前面的require，但增加了一个可选参数，该参数将被转为错误信息字符串。5 输入输出方法
Scala把数据打印到控制台，这是我们经常做的操作，其实他也是Predef定义的。Predef 为我们提供了四种将字符串打印到stdout 的形式。
def print(x : scala.Any) : scala.Unit = { /* compiled code */ }
def println() : scala.Unit = { /* compiled code */ }
def println(x : scala.Any) : scala.Unit = { /* compiled code */ }
def printf(text : Predef.String, xs : scala.Any*) : scala.Unit = { /* compiled code */ }• def print(x: Any): Unit
将x 转为字符串，然后写到标准输出，结尾不会自动添加换行。
• def printf(format: String, xs: Any*): Unit
用format 和其他参数xs 对printf 风格的字符串进行格式化，然后将结果写到标准输出，结尾不会自动添加换行。
• def println(x: Any): Unit
类似print，但结尾会自动添加换行。
• def println(): Unit
向标准输出打印空行。
在老的版本中（2.12之前）Predef提供了相当多的输入方法：
@scala.deprecated("use the method in `scala.io.StdIn`", "2.11.0")
def readLine() : DeprecatedPredef.super[Predef/*scala.Predef*/].String = { /* compiled code */ }
@scala.deprecated("use the method in `scala.io.StdIn`", "2.11.0")
def readLine(text : DeprecatedPredef.super[Predef/*scala.Predef*/].String, args : scala.Any*) : _root_.scala.Predef.String = { /* compiled code */ }
@scala.deprecated("use the method in `scala.io.StdIn`", "2.11.0")
def readBoolean() : scala.Boolean = { /* compiled code */ }
@scala.deprecated("use the method in `scala.io.StdIn`", "2.11.0")
def readByte() : scala.Byte = { /* compiled code */ }
@scala.deprecated("use the method in `scala.io.StdIn`", "2.11.0")
def readShort() : scala.Short = { /* compiled code */ }
@scala.deprecated("use the method in `scala.io.StdIn`", "2.11.0")
def readChar() : scala.Char = { /* compiled code */ }
@scala.deprecated("use the method in `scala.io.StdIn`", "2.11.0")
def readInt() : scala.Int = { /* compiled code */ }
@scala.deprecated("use the method in `scala.io.StdIn`", "2.11.0")
def readLong() : scala.Long = { /* compiled code */ }
@scala.deprecated("use the method in `scala.io.StdIn`", "2.11.0")
def readFloat() : scala.Float = { /* compiled code */ }
@scala.deprecated("use the method in `scala.io.StdIn`", "2.11.0")
def readDouble() : scala.Double = { /* compiled code */ }
@scala.deprecated("use the method in `scala.io.StdIn`", "2.11.0")
def readf(format : DeprecatedPredef.super[Predef/*scala.Predef*/].String) : scala.List[scala.Any] = { /* compiled code */ }
@scala.deprecated("use the method in `scala.io.StdIn`", "2.11.0")
def readf1(format : DeprecatedPredef.super[Predef/*scala.Predef*/].String) : scala.Any = { /* compiled code */ }
@scala.deprecated("use the method in `scala.io.StdIn`", "2.11.0")
def readf2(format : DeprecatedPredef.super[Predef/*scala.Predef*/].String) : scala.Tuple2[scala.Any, scala.Any] = { /* compiled code */ }
@scala.deprecated("use the method in `scala.io.StdIn`", "2.11.0")
def readf3(format : DeprecatedPredef.super[Predef/*scala.Predef*/].String) : scala.Tuple3[scala.Any, scala.Any, scala.Any] = { /* compiled code */ }• def readBoolean(): Boolean
从标准输入的一个整行中读取一个Boolean 值。
• def readByte(): Byte
从标准输入的一个整行中读取一个Byte 值。
• def readChar(): Char
从标准输入的一个整行中读取一个Char 值。
• def readDouble(): Double
从标准输入的一个整行中读取一个Double 值。
• def readFloat(): Float
从标准输入的一个整行中读取一个Float 值。
• def readInt(): Int
从标准输入的一个整行中读取一个Int 值。
• def readLine(text: String, args: Any*): String
向标准输出中打印格式化的提示文本，并从标准输入中读取一整行字符串。
• def readLine(): String
从标准输入中读取一整行字符串。
• def readLong(): Long
从标准输入的一个整行中读取一个Long 值。
• def readShort(): Short
从标准输入的一个整行中读取一个Short 值。
• def readf(format: String): List[Any]
根据format 中的区分符号，从标准输入中读取格式化输入。
• def readf1(format: String): Any
根据format 中的区分符号，从标准输入中读取格式化输入。并根据format 的指定，返回提取的第一个值。
• def readf2(format: String): (Any, Any)
根据format 中的区分符号，从标准输入中读取格式化输入。并根据format 的指定，返回提取的前两个值。
• def readf3(format: String): (Any, Any, Any)
根据format 中的区分符号，从标准输入中读取格式化输入。并根据format 的指定，返回提取的前三个值。
在输入时也可以选择Java的方式：
val read:Scanner = new Scanner(System.in)
val line = read.nextLine()
val b = read.nextByte()
val s = read.nextShort()
val i = read.nextInt()
val f = read.nextFloat()
val d = read.nextDouble()
val l = read.nextLong()
val bool = read.nextBoolean()6 杂项方法
1 ???
在一个尚未实现的方法的方法体中调用。它为方法提供了具体的定义，允许编译器将方法所属的类型视为具体（与抽象对应）的类。然而，如果调用该方法，就会抛出scala.NotImplementedError 异常。源码如下：
def ??? : scala.Nothing = { /* compiled code */ }2 identity
直接返回参数x。在将方法传给组合器（combinator）时，如果不需要进行修改，就可以用它。例如：在一个工作流程中，我们通过给map 传入一个函数来对集合元素进行转化。有时我们不需要做任何转化，你可以传入identity。源码如下：
@scala.inline
def identity[A](x : A) : A = { /* compiled code */ }3 implicitly
当隐式参数列表使用简写[T:M] 时，编译器会添加形式为(implicit arg: M[T]) 的隐式参数列表（实际名称不是arg，而是编译器合成的唯一名称）。调用implicitly 可以返回参数arg。源码如下：
@scala.inline
def implicitly[T](implicit e : T) : T = { /* compiled code */ }看一个例子：
package cn.com.tengen.test.obj
class Test{
}
case class MyList[A](list: List[A]) {
def sortBy1[B](f: A => B)(implicit ord: Ordering[B]): List[A] =
list.sortBy(f)(ord)
def sortBy2[B : Ordering](f: A => B): List[A] =
list.sortBy(f)(implicitly[Ordering[B]])
}
object Test {
def main(args: Array[String]): Unit = {
val list = MyList(List(1,3,5,2,4))
val l1 = list sortBy1 (i => -i)
val l2 = list sortBy2 (i => -i)
println(l1)
println(l2)
}
}有些集合提供了一些排序方法，List.sortBy 便是其中之一。List.sortBy 方法的第一个参数类型为函数，该输入函数能够将函数的输入参数转化为另一个满足math.Ordering 条件的类型。而math.Ordering 是与Java 中的Comparable抽象等同的类型。List.sortBy 方法的另一个参数则为隐式参数，该参数知道如何对类型B 的实例进行排序。
MyList 类提供了两种方式编写像sortBy 类型的方法。第一种实现：sortBy1 方法应用了我们已知的语法。该方法接受一个额外的类型为Ordering[B] 的隐式值作为其输入。调用sortBy1 方法时，在当前作用域中一定存在某一Ordering[B] 的对象实例，该实例清楚地知道如何对我们所需要的B 类型对象进行排序。我们认为B 的界限被“上下文”所限定，在这个例子中，上下文限定了B 对实例进行排序的能力。
由于这种Scala 方言应用非常普遍，因此Scala 提供了一个简化版的语法，这正是第二类实现 sortBy2 所使用的语法。类型参数B : Ordering被称为 上下文定界（ context bound）， 它暗指第二个参数列表（也就是那个隐式参数列表）将接受Ordering[B] 实例。
不过，我们仍需要在方法中访问Ordering 对象实例。由于在源代码中我们不再明确地声明Ordering 对象实例，因此这个实例没有自己的名称。针对这种现象我们该怎么办呢？Predef.implicitly 方法帮我们解决了这个问题。implicitly 方法会对传给函数的所有标记为隐式参数的实例进行解析。请注意implicitly 方法所需要的类型签名，在本例中Ordering[B] 是其类型签名。
4.Pair 与 Triple
Pair是一个二元组，Triple是一个三元组
源码：
@scala.deprecated("use built-in tuple syntax or Tuple2 instead", "2.11.0")
type Pair[+A, +B] = scala.Tuple2[A, B]
@scala.deprecated("use built-in tuple syntax or Tuple2 instead", "2.11.0")
object Pair extends scala.AnyRef {
def apply[A, B](x : A, y : B) : scala.Tuple2[A, B] = { /* compiled code */ }
def unapply[A, B](x : scala.Tuple2[A, B]) : scala.Option[scala.Tuple2[A, B]] = { /* compiled code */ }
}
@scala.deprecated("use built-in tuple syntax or Tuple3 instead", "2.11.0")
type Triple[+A, +B, +C] = scala.Tuple3[A, B, C]
@scala.deprecated("use built-in tuple syntax or Tuple3 instead", "2.11.0")
object Triple extends scala.AnyRef {
def apply[A, B, C](x : A, y : B, z : C) : scala.Tuple3[A, B, C] = { /* compiled code */ }
def unapply[A, B, C](x : scala.Tuple3[A, B, C]) : scala.Option[scala.Tuple3[A, B, C]] = { /* compiled code */ }
}5. Map与Set
我们先可一个例子：
object Test {
def main(args: Array[String]): Unit = {
val map = Map(1->"aaa",2->"BBB")
val set = Set(1,2,33,44,44,6)
println(map)
println(set)
}
}这里我们用的Map和Set都是Predef中的两个属性，而并没有直接导入scala.collection.immutable.Map和scala.collection.immutable.Set，看源码：
type Map[A, +B] = scala.collection.immutable.Map[A, B]
type Set[A] = scala.collection.immutable.Set[A]
val Map : scala.collection.immutable.Map.type = { /* compiled code */ }
val Set : scala.collection.immutable.Set.type = { /* compiled code */ }