Scala的变量，数组，元组和分支循环

变量

Scala语言中没有原始数据类型，这一点和Java语言不同，在Scala中一切且对象。以下是Scala语言中常见类型和类型间的继承关系。

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

变量声明

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

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

scala> var i:Int=1:Int
i: Int = 1
scala> var j=100:Byte
j: Byte = 100

使用常量声明的变量，不能重复赋值

scala> val i=10:Float
i: Float = 10.0

scala> i=10.2
<console>:12: error: reassignment to val
       i=10.2

Scala虽然可以做类型⾃动推断，类型⼀旦确定，不允许更改-强类型编程语⾔。

scala> var i=20:Int
i: Int = 20

scala> i=true
<console>:12: error: type mismatch;
 found   : Boolean(true)
 required: Int
       i=true

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

数值转换 （重点）

scala中数据类型相互兼容时，如果是由小到大进行赋值，可以直接执行。

scala> var a=10:Int
a: Int = 10
scala> var b=20:Long
b: Long = 20
scala> b=a
b: Long = 10

如果是由大到小进行赋值，直接赋值会出错，可使用函数 asInstanceOf[类型] 进行强转(数据类型必须兼容)。

scala> var a=10:Int
a: Int = 10
scala> var b=10:Long
b: Long = 10
scala> a=b.asInstanceOf[Int]
a: Int = 10

String转换为AnyVal类型（重点）

想要转换为哪种类型，就是用哪种 to类型 函数

scala> var s="123":String
s: String = 123
scala> var a=s.toInt
a: Int = 123

scala> var s="true"
s: String = true
scala> var b=s.toBoolean
b: Boolean = true

数组

数组声明

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

var 数组名 = Array[类型](数值1，数值2，数值3...)
var 数组名 = new Array[类型]（数组长度）       ---创建一个空的数组

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

获取数组的值

scala> a(0)
res0: Double = 1.0
scala> a
res1: Array[Double] = Array(1.0, 2.0, 3.0, 4.0, 5.0)

scala> a.length
res2: Int = 5
scala> a.size
res3: Int = 5

遍历⼀个数组

for(i <- a) {print(i)}

scala> for(i <- 0 until a.length) {println(a(i)}
1.0
2.0
3.0
4.0
5.0

scala> a.foreach(item=> println(item)) //细化的
1
2
3
4
5

元组（重点）

元组声明

若干个指定类型的元素构成的一个只读的复合变量，称之为元组。(元素最多22个)

scala> var a=(1,"zhangsan",true,18)
a: (Int, String, Boolean, Int) = (1,zhangsan,true,18)

元组中的元素都是val类型不允许修改（只读），但是元组变量可以修改

scala> var a=(2,"lisi",false,20)
a: (Int, String, Boolean, Int) = (2,lisi,false,20)

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

元组数据的访问

scala> a
res1: (Int, String, Boolean, Int) = (2,lisi,false,19)
scala> a._1
res10: Int = 1
scala> a._2
res3: String = lisi

Unit类型

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

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

分支循环

if 条件分支

if(条件){
    
}else if(条件){
    
}else{
    
}

var age=20
if(age < 18){
    print(s"儿童 年龄${age}")
}else if(age < 30){
    print(s"青年 年龄$age")
}else{
    print(s"壮年 年龄$age")
}

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

var age=40
var message= if (age < 18) {
    s"儿童 年龄${age}"
}else if(age < 30){
    s"青年 年龄$age"
}else{
    s"壮年 年龄$age"
}
print (s"最终结果：$message")

while 、do-while

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

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

也没有 i++ 和 i–

var i=1
while(i<=5){
    println(s"当前i的值为:$i")
    i=i+1
}

Breaks

Scala 语⾔中默认是没有 break 语句，但是在 Scala 2.8 版本后可以使⽤另外⼀种⽅式来实现 break 语
句。当在循环中使⽤ break 语句，在执⾏到该语句时，就会中断循环并执⾏循环体之后的代码块。

首先导入breaks包

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

var break = new Breaks
var a=10
break.breakable({
    do{
        print("\t"+a)
        a-=1
        if(a==5){
            break.break()
        }      
    }while(a>0)
})

for 循环 （重点）

迭代遍历数组

var array = Array(4,3,2,1)
for(i <- array){print(i+"\t")}

通过下标迭代数组

var array = Array(4,3,2,1)
for(i <- 0 until array.length){
    print(array(i)+"\t")
}

for 可以使用多个循环因子 —打印九九乘法表

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

for 可以和 if 联用

for(i <- 1 to 10;if(i%2 == 0)){
    print(i+"\t")
}

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

var array = Array(4,3,2,1)
var res = for(item <- array) yield item*item

match-case(模式匹配)

在Scan中剔除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
}
print(res)

new Random().nextInt(3)           产生一个0到3的随机数，但不包括0和3

② 类型配置

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

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