Scala 常量值

Scala常量值

整数常量

整数常量可以用十进制,十六进制或八进制表示。

详细总结在下表中。

类型格式例子
Decimal0或非零数字后跟零或多个数字(0-9)0, 1, 321
Hexadecimal0x后跟一个或多个十六进制数字(0-9,A-F,a-f)0xFF, 0x1a3b
Octal0后跟一个或多个八进制数字(0-7)a013, 077

截至Scala 2.10,一个八进制常量已被弃用。

您可以通过在常量前添加一个 -号来表示负数。

对于长文本,需要在文本末尾附加Ll字符,除非将值分配给声明为Long的变量。 

否则,推断Int。

整数字符串的有效值受要为其分配值的变量的类型的限制。

下表定义了包含的限制。

目标类型最低(含)最大(包括)
Long-263263
Int-231231 - 1
Short-215215
Char0216
Byte-2727 - 1

如果指定的整数常量数超出这些范围,则会发生编译时错误。

浮点常量

浮点常量是带有可选减号,零个或多个数字,后跟句点.,后跟一个或多个数字的表达式。

对于 Float 常量,在文字末尾附加Ff字符。否则,假定为Double。

我们可以选择为D加上D d

浮点常量可以用或不用指数表示。

指数部分的格式为e或E,后跟可选的+或 - ,后跟一个或多个数字。

这里有一些浮点常量的例子。 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 

布尔常量

布尔常量是truefalse

它们被分配到的变量的类型将被推断为布尔值:

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

字符常量

字符常量是可打印的Unicode字符或转义序列,写在单引号之间。

Unicode值介于0和255之间的字符可以由八进制转义表示,即反斜杠(\)后跟最多三个八进制字符的序列。

这里有些例子:

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

有效的转义序列如下表所示。

序列含义
\b退格(BS)
\t水平制表(HT)
\n换行(LT)
\f换页(FF)
\r回车(CR)...
\"双引号(“)
\"单引号(“)
\\反斜杠(\)

字符串常量

字符串常量是用双引号或三重双引号括起来的字符序列,即“”“...”“”。

对于双引号中的字符串字符,允许的字符与字符常量相同。

要在字符串中包含双引号字符,必须使用\ 字符“转义"。

这里有些例子:

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

由双引号的三元组界定的字符串常量称为多行字符串常量。

这些字符串可以覆盖几行。换行符将是字符串的一部分。它们可以包括任何字符,包括一个或两个双引号在一起,但不能三个在一起。

它们对于不具有有效Unicode或转义序列的\字符的字符串非常有用。

这里有三个示例字符串:

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

Fourth line""" 

在代码中使用多行字符串时,要使用String.stripMargin缩进子字符串以进行正确的代码格式化。

它删除子字符串中的所有空格,直到并包括垂直条|的第一次出现。

要添加空格缩进,请将空格放在|后面。

考虑这个例子:

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   
}

要使用不同于|的前导字符,请使用带有Char(字符)参数的stripMargin的重载版本。

如果整个字符串都有要删除的前缀或后缀,则有相应的前缀和stripSuffix方法。

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

符号常量

Scala有符号类型,它们是内部连接的字符串,意味着具有相同“名称”的两个符号实际上是指内存中的同一个对象。

符号常量是单引号',后跟一个或多个数字,字母或下划线(“_”),但第一个字符不能是数字。

函数常量

(i:Int,s:String)=> s + i 是Function2类型的函数文本[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),以及括号内的项的逗号分隔列表的文字语法。

对于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 )
  }
}

表达式t._n从元组t中检索第n个项,从一个开始,不是零,遵循历史约定。

有几种方法来定义两元素元组,有时称为一对。

我们可以在两个值之间使用“箭头运算符”,以及在元组相关类上使用特殊的工厂方法:

(1, "one") 
1 -> "one" 
Tuple2(1, "one") 
以上内容是否对您有帮助:
在线笔记
App下载
App下载

扫描二维码

下载编程狮App

公众号
微信公众号

编程狮公众号

意见反馈
返回顶部