Scala的Predef對象有什么作用

本篇內(nèi)容主要講解“Scala的Predef對象有什么作用”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學(xué)習(xí)“Scala的Predef對象有什么作用”吧!

Scala的Predef對象

隱式引用(Implicit Import)

Scala會自己主動為每一個程序加上幾個隱式引用，就像Java程序會自己主動加上java.lang包一樣。

Scala中。下面三個包的內(nèi)容會隱式引用到每一個程序上。所不同的是。Scala還會隱式加進(jìn)對Predef的引用。這極慷慨便了程序猿的工作。

import java.lang._ // in JVM projects, or system namespace in .NET
import scala._     // everything in the scala package
import Predef._    // everything in the Predef object

上面三個包，包括了經(jīng)常使用的類型和方法。java.lang包包括了經(jīng)常使用的java語言類型，假設(shè)在.NET環(huán)境中，則會引用system命名空間。相似的，scala還會隱式引用scala包，也就是引入經(jīng)常使用的scala類型。

請注意 
上述三個語句的順序藏著一點玄機。我們知道，通常，假設(shè)import進(jìn)來兩個包都有某個類型的定義的話，比方說，同一段程序。即引用了’scala.collection.mutable.Set’又引用了’import scala.collection.immutable.Set’則編譯器會提示無法確定用哪一個Set。這里的隱式引用則不同，假設(shè)有同樣的類型。后面的包的類型會將前一個隱藏掉。比方。java.lang和scala兩個包里都有StringBuilder。這樣的情況下，會使用scala包里定義的那個。java.lang里的定義就被隱藏掉了，除非顯示的使用java.lang.StringBuilder。

Predef對象

Predef提供經(jīng)常使用函數(shù)

包scala中的Predef對象包括了很多實用的方法。比如，Scala源文件里寫下println語句，實際調(diào)用的是Predef的println。Predef.println 轉(zhuǎn)而調(diào)用 Console.println，完整真正的工作。

def print(x: Any) = Console.print(x)
def println() = Console.println()
def println(x: Any) = Console.println(x)
def printf(text: String, xs: Any*) = Console.print(text.format(xs: _*)

斷言函數(shù)assert以及相關(guān)函數(shù)也是在Predef中定義的：

** Tests an expression, throwing an `AssertionError` if false.
*  Calls to this method will not be generated if `-Xelide-below`
*  is at least `ASSERTION`.
*
*  @see elidable
*  @param assertion   the expression to test
*/
@elidable(ASSERTION)
def assert(assertion: Boolean) {
if (!assertion)
  throw new java.lang.AssertionError("assertion failed")
}


/** Tests an expression, throwing an `AssertionError` if false.
*  Calls to this method will not be generated if `-Xelide-below`
*  is at least `ASSERTION`.
*
*  @see elidable
*  @param assertion   the expression to test
*  @param message     a String to include in the failure message
*/
@elidable(ASSERTION) @inline
final def assert(assertion: Boolean, message: => Any) {
if (!assertion)
  throw new java.lang.AssertionError("assertion failed: "+ message)
}

Predef定義類型別名

Predef是一個對象（Object）。這個對象中，定義一些類型別名。如：

scala.collection.immutable.List         // to force Nil, :: to be seen.

type Function[-A, +B] = Function1[A, B]

type Map[A, +B] = immutable.Map[A, B]
type Set[A]     = immutable.Set[A]
val Map         = immutable.Map
val Set         = immutable.Set

如今我們知道了。直接使用集合時，如List。Map。Set。用到的是immutable包中的對象。這是在Predef里定義的。

隱式轉(zhuǎn)換

Predef對象定義了經(jīng)常使用的隱式轉(zhuǎn)換，如：

implicit final class any2stringadd[A](private val self: A) extends AnyVal {
  def +(other: String): String = String.valueOf(self) + other
}

該隱式轉(zhuǎn)換。給AnyVal的全部子類型都加上了+(other: String): String方法，便于在打印或其它字符串操作時，增加其它的值類型。

再如：

@inline implicit def augmentString(x: String): StringOps = new StringOps(x)
@inline implicit def unaugmentString(x: StringOps): String = x.repr

該隱式轉(zhuǎn)換，使得我們能夠自由的對String使用StringOps的方法。 
同理，數(shù)值類型的富包裝（Rich Wrapper）也是這樣實現(xiàn)的。

Scala程序猿能夠較少關(guān)心裝箱和拆箱操作，這也是因為Predef對象里定義了Scala值類型與java基本類型直接的隱式轉(zhuǎn)換。

implicit def byte2Byte(x: Byte)           = java.lang.Byte.valueOf(x)
implicit def short2Short(x: Short)        = java.lang.Short.valueOf(x)
implicit def char2Character(x: Char)      = java.lang.Character.valueOf(x)
implicit def int2Integer(x: Int)          = java.lang.Integer.valueOf(x)
implicit def long2Long(x: Long)           = java.lang.Long.valueOf(x)
implicit def float2Float(x: Float)        = java.lang.Float.valueOf(x)
implicit def double2Double(x: Double)     = java.lang.Double.valueOf(x)
implicit def boolean2Boolean(x: Boolean)  = java.lang.Boolean.valueOf(x)

implicit def Byte2byte(x: java.lang.Byte): Byte             = x.byteValue
implicit def Short2short(x: java.lang.Short): Short         = x.shortValue
implicit def Character2char(x: java.lang.Character): Char   = x.charValue
implicit def Integer2int(x: java.lang.Integer): Int         = x.intValue
implicit def Long2long(x: java.lang.Long): Long             = x.longValue
implicit def Float2float(x: java.lang.Float): Float         = x.floatValue
implicit def Double2double(x: java.lang.Double): Double     = x.doubleValue
implicit def Boolean2boolean(x: java.lang.Boolean): Boolean = x.booleanValue

關(guān)于裝箱（Boxing）和拆箱（Unboxing） 
熟悉Java或C#等語言的讀者會知道，裝箱是指將原始類型轉(zhuǎn)換成引用類型（對象）。用于須要對象的操作，而拆箱，則是把對象轉(zhuǎn)換成原始類型，用于須要原始類型的場景。 
因為數(shù)值類型本身已經(jīng)是類對象，因此Scala里不須要裝箱（boxing）和拆箱（unboxing）操作。

當(dāng)然，Scala代碼終于會執(zhí)行在JVM上，所以實際上，始終會有裝箱成Scala類對象，和拆箱成Java原始值類型的操作，可是這些操作是透明的，程序猿不須要關(guān)心（實際上，這是由定義在Predef中的隱式轉(zhuǎn)換完畢的）。

到此，相信大家對“Scala的Predef對象有什么作用”有了更深的了解，不妨來實際操作一番吧！這里是億速云網(wǎng)站，更多相關(guān)內(nèi)容可以進(jìn)入相關(guān)頻道進(jìn)行查詢，關(guān)注我們，繼續(xù)學(xué)習(xí)！