Scala变量

变量

Scala是一种纯粹的面向对象编程的语言。Scala语言中没有原始数据类型，这一点和Java语言不同，在Scala中一切皆对象。一下是Scala语言中常见类型和类型间的继承关系。

在Java中常见的基本类型在Scala中都被剔除了，Scala将值类型和引用类型分离。所有的数值变量类型都是AnyVal的子类，这些变量的值都有字面值。对于一些对象类型的变量都是AnyRef的子类。对于AnyRef类下的变量(除String类型)，一般不允许直接赋值字面量，都需要借助new关键字创建。

变量声明

Scala语言是一种可以做类型自动推断的强类型的编程语言。变量的类型可通过编译器在编译的时候推断出最终类型。因此Scala中声明一个变量主要告知编译器该变量的值是常量还是变量，例如：例如声明一个变量使用var即可，如果声明的是一个常量使用val关键字。因此Scala中变量声明的语法如下：

var|val 变量名字[:类型]=变量值[:类型]

Scala虽然可以做类型自动推断，类型一旦确定，不允许更改-强类型编程语言。val表示声明常量。

总结：所有AnyVal类型的子类在声明字面值的时候，系统一般都可以自动推断出字面量类型，所以一般情况下可以省略类型的声明。

数值转换

数据类型兼容，且由小到大可以直接赋值。

scala> var i=1
i: Int = 1

scala> var b=2:Byte
b: Byte = 2

scala> i=b
i: Int = 2

scala> b=i
<console>:13: error: type mismatch;
 found   : Int
 required: Byte
       b=i

由大到小需要强转

scala> b=i.asInstanceOf[Byte]
b: Byte = 2

**注意：**能够实现数值转换的，要求类型必须是兼容的。

scala> var num="123"
num: String = 123

scala> var i=100
i: Int = 100

scala> i=num
<console>:13: error: type mismatch;
 found   : String
 required: Int
       i=num
         ^

scala> i=num.asInstanceOf[Int]
java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
  at scala.runtime.BoxesRunTime.unboxToInt(BoxesRunTime.java:101)
  ... 32 elided

String转换为AnyVal类型

scala> var a="100.5"
a: String = 100.5

scala> var d=1.0d
d: Double = 1.0

scala> d=a.toDouble
d: Double = 100.5

数组

Scala提供了简便的声明和使用数组的方式，例如声明一个Int类型的数组，则使用如下：

scala> var a=Array(1,3,5,6)
a: Array[Int] = Array(1, 3, 5, 6)

scala> var a=new Array[Int](5)
a: Array[Int] = Array(0, 0, 0, 0, 0)

获取数组的值

scala> var a=Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)

scala> a(1)
res0: Int = 2

scala> a(0)
res1: Int = 1

scala> a(0)=-1
<console>:13: error: value =- is not a member of Int
       a(0)=-1
           ^

scala> a(0)= -1

scala> a
res4: Array[Int] = Array(-1, 2, 3, 4, 5)

scala> a.length
res5: Int = 5

scala> a.size
res6: Int = 5

遍历一个数组

scala> for(i <- 0 until a.length) println(a(i))
-1
2
3
4
5

scala> a.foreach(item => println(item))
-1
2
3
4
5

元组

由若干个指定类型的元素构成一个只读的复合变量(变量的属性不可更改)，成为元组类型。

scala> for(i <- 0 until a.length) println(a(i))
-1
2
3
4
5

scala> a.foreach(item => println(item))
-1
2
3
4
5

元组数据访问

scala> a
res9: (Int, String, Boolean, Int) = (2,lisi,false,19)

scala> a._1
res10: Int = 2

scala> a._2
res11: String = lisi

scala> a._2="wangwu"
<console>:12: error: reassignment to val
       a._2="wangwu"

元组中元素都是只读的，一般由值类型和String构成。在Scala一个Tuple最多能够有22个成员。元组中的元素都是val类型不允许修改，但是元组变量可以修改

Unit类型

Scala中将void作为保留关键字，使用Unit作为void替换品，在Scala中Unit表示什么也没有的对象。因此字面量()

scala> var u=()
u: Unit = ()

分支循环

if条件分支

语法

if(条件){

}else if(条件){

}
...
else{

}

var age=35
      if(age<18){
        print(s"你是少年，你的年龄：${age}")
      }else if(age<30){
        print(s"你是青年，你的年龄：${age}")
      }else{
        print(s"你是中年，你的年龄：${age}")
      }

根据age参数计算msg的取值，可以看出在Scala语法中if分支可以作为变量的赋值语句。可以将分支中返回的结果作为返回值，在利用分支做赋值的时候，不可以给return关键字，系统会自动将代码块最后一行的结果作为返回值。

var age=35
      var message= if(age<18){
        println("=======")
        s"你是少年，你的年龄：${age}"
      }else if(age<30){
        println("+++++++")
        s"你是青年，你的年龄：${age}"
      }else{
        println("--------")
        s"你是中年，你的年龄：${age}"
      }
      println(s"最终结果：${message}")

while、do-while

while(条件){
	//循环体
}

在Scala中while和do-while没有continue和break关键字。

var i=5
    while(i>0){
      println(s"当前i的值：${i}")
      i = i-1
    }

    println("```````````")
    i=5
    do{
      println(s"当前i的值：${i}")
      i = i-1
    }while(i>0)

Breaks

Scala语言中默认是没有break语句，但是在Scala2.8版本之后可以使用另外一种方式来实现break语句。当在循环中使用break语句，在执行到该语句时，就会中断循环并执行循环体之后的代码块。

scala> import scala.util.control.Breaks
import scala.util.control.Breaks

scala> var a=10
a: Int = 10

scala>     var break = new Breaks
break: scala.util.control.Breaks = scala.util.control.Breaks@44aaa987

scala>     break.breakable({
     |       do{
     |         print("\t"+a)
     |         a -= 1
     |         if(a<=5){
     |           break.break()
     |         }
     |       }while(a>0)
     |     })
        10      9       8       7       6

for循环-重点

• 迭代遍历数组

scala> var array=Array(1,2,3,4)
array: Array[Int] = Array(1, 2, 3, 4)

scala> for(item <- array){print(item+"\t")}
1       2       3       4

• 通过下标遍历数组

scala> var array=Array(1,2,3,4)
array: Array[Int] = Array(1, 2, 3, 4)

scala>     for(i <- 0 until array.length){
     |       print(array(i))
     |     }
1234

• for可使用多个循环因子

for(i <- 1 to 9){
      for(j <- 1 to i){
        print(s"${i} * ${j} = "+(i*j)+"\t")
        if(i == j){
          println()
        }
      }
    }

for(i <- 1 to 9; j <- 1 to i){
      print(s"${i} * ${j} = "+(i*j)+"\t")
      if(i == j){
        println()
      }
    }

• for和if的使用

scala> for(i <- 0 to 10;if(i%2==0)){
     |       print(i+"\t")
     |     }
0       2       4       6       8       10

• for和yield关键字实现元素的提取，创建子集(重点)

scala> var a=Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)

scala>     var res=for(item <- a) yield item*item
res: Array[Int] = Array(1, 4, 9, 16, 25)

match-case(模式匹配)

在Scala中剔除java中switch-case语句，提供了match-case替代方案，该方案不仅仅可以按照值匹配，还可以按照类型、以及值的结构(数组匹配、元组匹配、case-class匹配等)

• 值匹配

var a=Array(1,2,3)
    var i=a(new Random().nextInt(3))
    var res= i match {
      case 1 => "one"
      case 2 => "two"
      case 3 => "three"
      case default => null
    }
    println(res)

• 类型匹配

var a=Array(100,"zhangsan",true,new Date())
    var i=a(new Random().nextInt(4))
    var res= i match {
      case x: Int => s"age:$x"
      case x: String => s"name:$x"
      case x:Boolean => s"sex:$x"
      case _ => "啥都不是"
    }
    println(res)

注意： _表示默认匹配等价default关键字