Scala 常量值

整數(shù)常量

整數(shù)常量可以用十進(jìn)制，十六進(jìn)制或八進(jìn)制表示。

詳細(xì)總結(jié)在下表中。

截至Scala 2.10，一個八進(jìn)制常量已被棄用。

您可以通過在常量前添加一個 -號來表示負(fù)數(shù)。

對于長文本，需要在文本末尾附加L或l字符，除非將值分配給聲明為Long的變量。 

否則，推斷Int。

整數(shù)字符串的有效值受要為其分配值的變量的類型的限制。

下表定義了包含的限制。

如果指定的整數(shù)常量數(shù)超出這些范圍，則會發(fā)生編譯時錯誤。

浮點常量

浮點常量是帶有可選減號，零個或多個數(shù)字，后跟句點.，后跟一個或多個數(shù)字的表達(dá)式。

對于 Float 常量，在文字末尾附加F或f字符。否則，假定為Double。

我們可以選擇為D加上D 或 d 。

浮點常量可以用或不用指數(shù)表示。

指數(shù)部分的格式為e或E，后跟可選的+或 - ，后跟一個或多個數(shù)字。

這里有一些浮點常量的例子。 Double被推斷除非聲明的變量是Float或使用f或F后綴：

     .14 
     3.14 
     3.14f 
     3.14F 
     3.14d 
     3.14D 
     3e5 
     3E5 
     3.14e+5 
     3.14e-5 
     3.14e-5 
     3.14e-5f 
     3.14e-5F 
     3.14e-5d 
     3.14e-5D 

布爾常量

布爾常量是true和false。

它們被分配到的變量的類型將被推斷為布爾值：

 
object Main {
  def main(args: Array[String]) {
     val b1 = true 
     val b2 = false 
     
     println(b1);
     println(b2);
  }    
}

字符常量

Unicode值介于0和255之間的字符可以由八進(jìn)制轉(zhuǎn)義表示，即反斜杠（\）后跟最多三個八進(jìn)制字符的序列。

這里有些例子：

"A" 
"\u0041"  // "A" in Unicode 
"\n" 
"\012"    // "\n" in octal 
"\t" 

有效的轉(zhuǎn)義序列如下表所示。

字符串常量

字符串常量是用雙引號或三重雙引號括起來的字符序列，即“”“...”“”。

對于雙引號中的字符串字符，允許的字符與字符常量相同。

要在字符串中包含雙引號“字符，必須使用\ 字符“轉(zhuǎn)義"。

這里有些例子:

"This is a\ntest" 
"He said, \"SQL is for database!\"" 
"First\tSecond" 

由雙引號的三元組界定的字符串常量稱為多行字符串常量。

這些字符串可以覆蓋幾行。換行符將是字符串的一部分。它們可以包括任何字符，包括一個或兩個雙引號在一起，但不能三個在一起。

它們對于不具有有效Unicode或轉(zhuǎn)義序列的\字符的字符串非常有用。

這里有三個示例字符串：

"""This is a \ntest""" 
"""He said, "SQL is for database!" """ 
"""First line\n 
Second line\t 

Fourth line""" 

在代碼中使用多行字符串時，要使用String.stripMargin縮進(jìn)子字符串以進(jìn)行正確的代碼格式化。

它刪除子字符串中的所有空格，直到并包括垂直條|的第一次出現(xiàn)。

要添加空格縮進(jìn)，請將空格放在|后面。

考慮這個例子:

object Main {
  def main(args: Array[String]) {
     println(hello("This is a test") );
     
  }    
  def hello(name: String) = s"""Welcome! 
       Hello, $name! 
       * (Star!!) 
       |Hi. 
       |    whitespace.""" .stripMargin   
}

要使用不同于|的前導(dǎo)字符，請使用帶有Char（字符）參數(shù)的stripMargin的重載版本。

如果整個字符串都有要刪除的前綴或后綴，則有相應(yīng)的前綴和stripSuffix方法。

object Main {
  def main(args: Array[String]) {
     println(goodbye("m.o2fo.com"));
     
  }    
  def goodbye(name: String) = 
       s"""xxxGoodbye, ${name}yyy 
       xxxCome again!yyy""" .stripPrefix("xxx").stripSuffix("yyy") 
}

符號常量

Scala有符號類型，它們是內(nèi)部連接的字符串，意味著具有相同“名稱”的兩個符號實際上是指內(nèi)存中的同一個對象。

符號常量是單引號'，后跟一個或多個數(shù)字，字母或下劃線（“_”），但第一個字符不能是數(shù)字。

函數(shù)常量

(i:Int，s:String)=> s + i 是Function2類型的函數(shù)文本[Int，String，String]（返回String）。

你甚至可以使用常量語法作為類型聲明。

以下聲明是等效的：

val f1: (Int,String) => String       = (i, s) => s+i 
val f2: Function2[Int,String,String] = (i, s) => s+i 

元組常量

Scala庫包括用于將N個項分組的TupleN類（例如，Tuple2），以及括號內(nèi)的項的逗號分隔列表的文字語法。

對于1到22之間的N，有單獨的TupleN類。

例如，val tup =（“Hi”，2014）定義了一個Tuple2實例，其中第一個元素推斷String，第二個元素Int推斷。

Tuple實例是不可變的，第一類值，因此您可以將它們分配給變量，將它們作為值傳遞，并從方法中返回。

我們還可以使用常量語法為Tuple類型聲明：

val t1: (Int,String)       = (1, "two") 
val t2: Tuple2[Int,String] = (1, "two") 

以下示例演示使用元組：

object Main {
  def main(args: Array[String]) {
     val t = ("Hello", 1, 2.3)
     println( "Print the whole tuple: " + t )
     println( "Print the first item:  " + t._1 )
     println( "Print the second item: " + t._2 )
     println( "Print the third item:  " + t._3 )

     val (t1, t2, t3) = ("World",  "!", 0x22)
     println( t1 + ", " + t2 + ", " + t3 )

     val (t4, t5, t6) = Tuple3("World",  "!", 0x22)
     println( t4 + ", " + t5 + ", " + t6 )
  }
}

表達(dá)式t._n從元組t中檢索第n個項，從一個開始，不是零，遵循歷史約定。

有幾種方法來定義兩元素元組，有時稱為一對。

我們可以在兩個值之間使用“箭頭運算符”，以及在元組相關(guān)類上使用特殊的工廠方法：

(1, "one") 
1 -> "one" 
Tuple2(1, "one")