1- 变量

变量 mutable variable

在程序运行过程中其值可能发生改变的量
关键词var定义变量，定义时直接进行求值

常量 immutable variable

在程序运行过程中其值不会发生变化的量
在声明时就必须被初始化，而且一旦初始化后就不能再赋值；

关键词val定义常量，定义时直接进行求值；
关键词lazy val --- 惰性求值的常量，只有当该变量第一次被使用时才会被求值
常量不能修改。如果程序尝试修改常量的值，将会在编译时报错

变量类型引用

可以不显示指定变量的类型，Scala具有“类型推断”能力，会自动进行类型推导；
如果在没有指明数据类型的情况下声明变量或常量，必须要给出其初始值，否则将会报错；
一般情况下，如果定义的变量可能不会被用到，可以定义该变量为lazy val；

  val myStr = "Hello Scala!"                      //> myStr  : String = Hello Scala!

  val myStr2: String = "Hello Scala!"             //> myStr2  : String = Hello Scala!

示例-1：

scala> val x = 10  # 定义常量x

x: Int = 10  # Scala自动推导出x的类型是Int

scala> val y:Int =20  # 显示定义Int类型常量

y: Int = 20

scala> x + x  # 定义表达式

res0: Int = 20  # res0是Scala的REPL自动为没有变量名的表达式设置默认变量名，res是result的简写，0是默认变量的标号

scala> res0  # 直接引用表达式res0

res1: Int = 20  # 因为res0这个表达式没有变量名，所以REPL默认设置res1作为res0表达式结果的变量名

scala> res0*res1

res2: Int = 400

scala> val z=res0+res1+res2  # 为表达式指定变量名

z: Int = 440

scala> z = 100  # 为Z赋新值

<console>:12: error: reassignment to val  # 常量Z的值不可以被改变

       z = 100

         ^

scala> var a = 200  # 定义变量a

a: Int = 200

scala> a = 300  # 可以为变量a赋新值

a: Int = 300

scala> val d = 20

d: Int = 20

scala> val e = 30

e: Int = 30

scala> lazy val f = d * e  # 定义惰性常量f

f: Int = <lazy>  # f的值没有立即求解，<lazy>是惰性的标记

scala> f*10  # 当惰性常量第一次被使用时才会被求值

res3: Int = 6000

scala> f

res4: Int = 600

scala>

示例-2：

Scala 支持多个变量的声明
如果方法返回值是元组，可以使用 val 来声明一个元组

  val x, y = 100                                  //> x  : Int = 100

                                                  //| y  : Int = 100

  val test = (50, "demo")                         //> test  : (Int, String) = (50,demo)

2- 数据类型

Byte 8位有符号补码整数。数值区间为 -128 到 127
Short 16位有符号补码整数。数值区间为 -32768 到 32767
Int 32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long 64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807
Float 32位IEEE754单精度浮点数
Double 64位IEEE754单精度浮点数

Char 16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF
String 字符序列
Boolean true或false
Unit 表示无值，用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null null 或空引用，是每个引用类（继承自AnyRef的类）的子类
Nothing 任何其他类型的子类型，不包括无值

Any 所有其他类的超类
AnyRef Scala里所有引用类(reference class)的基类

2.1-字面量

字面量包括整数、浮点数、布尔型、字符、字符串、符号、函数和元组字面量。

Scala允许对“字面量”直接执行方法。

  val t = 123 //123就是整数字面量                        //> t  : Int = 123

  val t2 = 3.14 //3.14就是浮点数字面量                    //> t2  : Double = 3.14

  val t3 = true //true就是布尔型字面量                    //> t3  : Boolean = true

  val t4 = 'A' //'A'就是字符字面量                       //> t4  : Char = A

  val t5 = "Hello" //"Hello"就是字符串字面量              //> t5  : String = Hello

  "abc".intersect("bcd")                          //> res0: String = bc

注意：intersect()方法用来输出两个字符串中都存在的字符

2.2-数字类型

包括Byte、Short、Int、Long、Folat、Double，其中Float、Double浮点数。

低精度数字类型向高精度赋值时，不需要类型转换；高精度数字类型向低精度赋值时，需要类型转换。

scala> val a:Byte = 10

a: Byte = 10

scala> val b:Short = 20

b: Short = 20

scala> val c:Int = 30

c: Int = 30

scala> val d:Long = 40

d: Long = 40

scala> val e:Float = 50

e: Float = 50.0

scala> val f:Double = 60.98765

f: Double = 60.98765

scala> val x:Long = b  # Short类型常量b赋值给Long类型常量x，低精度赋值给高精度

x: Long = 20

scala> val y:Byte = x  # Long类型常量x赋值给Byte类型常量y，高精度赋值给低精度

<console>:12: error: type mismatch;  # 提示类型不匹配

 found   : Long

 required: Byte

       val y:Byte = x

                    ^

scala>

2.3-布尔类型

scala> val m=true

m: Boolean = true

scala> val n=false

n: Boolean = false

scala>

2.3-Unit

unit多作为函数的返回值出现，在函数式编程中表示函数是有副作用的，函数不返回任何的值

scala> val u:Unit = ()  # 显式声明Unit类型常量，()是文字量

u: Unit = ()

scala> val p=()

p: Unit = ()

scala>

2.4-Null和Nothing

Scala.Null和Scala.Nothing是用统一的方式处理某些"边界情况"的特殊类型。

Null表示一个引用类型的值是空，在Scala中通常不使用Null，而是使用？？
Nothing表示程序异常终止，如果函数返回值是Nothing，表明函数发生了异常。

scala> def foo() = throw new Exception("error occurred")

foo: ()Nothing

scala>

2.5-字符

字符表示：在半角单引号(')中的单个字符

scala> 'a'

res0: Char = a

scala> '\n'

res1: Char =

scala> '\t'

res2: Char =

scala> 'test'

<console>:1: error: unclosed character literal (or use " for string literal "test")

       'test'

            ^

scala>

2.6-字符串

String类型全称是java.lang.String，构建于Java的String之上，新增了字符串插值（interpolation）的特性。

也就是说，Scala的字符串是由Java的String类来实现的，也可以使用java.lang.String来声明。

默认情况下，Scala总会引入 java.lang._ 、 scala._ 和 Predef._，因此这里只需要使用String就可以声明变量。

  val myStr = "Hello Scala!"                      //> myStr  : String = Hello Scala!

  val myStr2: String = "Hello Scala!"             //> myStr2  : String = Hello Scala!

  val myStr3 : java.lang.String = "Hello Scala!"  //> myStr3  : String = Hello Scala!

单行字符串表示：在双引号(") 中包含的单行字符
多行字符串表示：在三个双引号(""")中包含的多行字符。

scala> val myname = "Anliven"

myname: String = Anliven

scala> s"My name is ${myname}"

res0: String = My name is Anliven

scala> """row 1

     | row 2

     | row 3"""

res1: String =

row 1

row 2

row 3

scala>

3- 打印语句

print语句：不换行打印
println语句：每次打印后追加一个换行符，实现换行的效果
printf函数：C语言风格格式化字符串

  print("This is a ")                             //> This is a

  print("test!")                                  //> test!

  println("This is a test!")                      //> This is a test!

  val test = 123456                               //> test  : Int = 123456

  println(test)                                   //> 123456

  printf("My name is %s, the ID is %d.\n", "Anliven", test)

                                                  //> My name is Anliven, the ID is 123456.

4- 操作符

在Scala中，可以使用加(+)、减(-) 、乘(*) 、除(/) 、余数（%）等操作符。

也可以使用大于(>)、小于(<)、大于等于(>=)和小于等于(<=)等关系和逻辑操作符，产生Boolean类型结果。

操作符本身就是方法，“a 方法 b”是“a.方法(b)”的简写形式，两者是等价的。

  val Sum1 = 6 + 2                                //> Sum1  : Int = 8

  val Sum2 = (6).+(2)                             //> Sum2  : Int = 8

在Scala中并没有提供“++”和“--”操作符，但可以“+=”方式来实现自增或自减

  var test = 1                                    //> test  : Int = 1

  test += 1

  println(test)                                   //> 2

注意：使用“+=”方式时，要使用var声明变量，否则执行时会报错。

5- 常见转义字符

0 到 255 间的 Unicode 字符可以用一个八进制转义序列来表示，即反斜线‟\‟后跟最多三个八进制。

  println("Hello World\n\nHello Scala");          //> Hello World

                                                  //|

                                                  //| Hello Scala

6- Range

Range可以支持创建不同数据类型的数值序列，包括Int、Long、Float、Double、Char、BigInt和BigDecimal等。

在创建Range时，需要给出区间的起点和终点以及步长（默认步长为1）。

  1 to 3                                          //> res0: scala.collection.immutable.Range.Inclusive = Range 1 to 3

  1.to(3)                                         //> res1: scala.collection.immutable.Range.Inclusive = Range 1 to 3

  1 until 3                                       //> res2: scala.collection.immutable.Range = Range 1 until 3

  1 to 10 by 3                                    //> res3: scala.collection.immutable.Range = Range 1 to 10 by 3

  0.5f to 5.9f by 0.8f                            //> res4: scala.collection.immutable.NumericRange[Float] = NumericRange 0.5 to 5.

                                                  //| 9 by 0.8

7- 代码块（code block）

在Scala中，代码块（code block）用于组织多个表达式。
代码块也是一个表达式，其最终求得的值是最后一个表达式的值。
只有一个表达式的代码块，花括号是可以省略的。

scala> var x = 10

x: Int = 10

scala> var y = 20

y: Int = 20

scala> x + y

res0: Int = 30

scala> {x*2;y*2;x*y}  # 代码块也是一个表达式，其最终求得的值是最后一个表达式的值。

res1: Int = 200

scala> {

     | x + y

     | x + x + y + y

     | }

res2: Int = 60

scala>

8- 函数

函数是一组一起执行一个任务的语句。
逻辑上，每个函数执行一个特定的任务。
定义函数最常用的方法是作为某个对象的成员，这种函数被称为方法。
方法是类的一部分，而函数是一个对象可以赋值给一个变量。

方法定义

Scala 函数定义格式如下：

def functionName ([参数列表]) : [return type] = {

   function body

   return [expr]

}

解释说明：

def 关键字声明函数定义，函数名functionName遵守命名规范
可选的[参数列表]，参数列表中的参数可以使用逗号分隔
冒号"：" 后是方法的返回类型[return type]，可以是任意合法的 Scala 数据类型
等于号"="后是方法的主体{}
function body：函数主体代码
return [expr]：返回值

  def hello(name: String): String = {

    s"hello, ${name}"

  }                                               //> hello: (name: String)String

  hello("Anliven")                                //> res0: String = hello, Anliven

  def hello2(name: String) = {

    s"hello, ${name}"

  }                                               //> hello2: (name: String)String

  hello2("Anliven")                               //> res1: String = hello, Anliven

  def add(x: Int, y: Int) = x + y                 //> add: (x: Int, y: Int)Int

  add (1,2)                                       //> res2: Int = 3

9- if表达式

if 语句

if是表达式而不是语句。
如果布尔表达式为 true 则执行大括号内的语句块，否则跳过大括号内的语句块，执行大括号之后的语句块。
if语句可以采用各种嵌套的形式。
Scala中的if表达式的值可以赋值给变量

if(布尔表达式)

{

   // 如果布尔表达式为 true 则执行该语句块

}

if...else 语句

if 语句后可以紧跟 else 语句，else 内的语句块可以在布尔表达式为 false 的时候执行。

if(布尔表达式){

   // 如果布尔表达式为 true 则执行该语句块

}else{

   // 如果布尔表达式为 false 则执行该语句块

}

一些示例：

  if (true) 1 else 2                              //> res0: Int = 1

  if (true) 3 else 4                              //> res1: Int = 3

  val a = 1                                       //> a  : Int = 1

  if (a == 1) a                                   //> res2: AnyVal = 1

  if (a != 1) "not one"                           //> res3: Any = ()  # 表达式不返回值，结果就是Unit的文字量（），

  if (a != 1) "not one" else a                    //> res4: Any = 1

scala> val x = 6

x: Int = 6

scala> :paste

// Entering paste mode (ctrl-D to finish)

if (x>0) {println("This is a positive number")

} else {

    println("This is not a positive number")

}

// Exiting paste mode, now interpreting.

This is a positive number

scala>

scala> :paste

// Entering paste mode (ctrl-D to finish)

if (x>0) {

    println("This is a positive number")

} else if (x==0) {

    println("This is a zero")

} else {

    println("This is a negative number")

}

// Exiting paste mode, now interpreting.

This is a positive number

scala>

scala> val test = if (x>0) 1 else -1

test: Int = 1

scala>

10- 循环

10.1-while循环

Scala中也有while和do-while循环语句。

  var x = 3                                       //> x  : Int = 3

  while (x > 0) {

    x -= 1

    printf("i is %d\n", x)

  }                                               //> i is 2

                                                  //| i is 1

                                                  //| i is 0

  var y = 0                                       //> y  : Int = 0

  do {

    y += 1

    println(y)

  } while (y < 3)                                 //> 1

                                                  //| 2

                                                  //| 3

10.2-for循环

语句格式：

for (变量<-表达式) 语句块  // 其中，“变量<-表达式”被称为生成器（generator）

for推导式：

带有yield关键字的for循环。
通过for循环遍历一个或多个集合，对集合中的元素进行“推导”，从而计算得到新的集合，用于后续的其他处理。