Scala基本语法

数据结构

一般分为两大类：
基本类型：Int,Double,Float,Short,Boolean,Byte,Unit
引用类型：String,数组，集合，对象
基本类型大体与Java中是一致的
Unit类似于Java中的void，没有任何实质性的意义，一般用于作为标识函数无返回值
Null类型是所有引用类型的子类
Nothing是所有类型的子类，一般用于作为函数返回值，用于明确的标识没有返回值

变量的定义

变量分为值可变和不可变

语法：
var/val 变量名称：数据类型 = 值(指定变量类型)
var/val 变量名称 = 值(不指定变量类型)

注意：
1.使用val修饰的变量，值不能修改，相当于Java中final修饰的变量
2.使用var修饰的变量，值可以修改
3.定义变量时，可以指定数据类型，也可以不指定，不指定时编译器会自动推测变量的数据类型

scala> var a:String = "itcast"
a: String = itcast
scala> println(a)
itcast
scala> a = "heima"
a: String = heima
scala> println(a)
heima
scala> var b:Int = 20
b: Int = 20
scala> b = 10
b: Int = 10
scala> println(a+"\t"+b)
heima   10
scala> var a = "spark"
a: String = spark
scala> var a = 1.9
a: Double = 1.9
scala> var a = false
a: Boolean = false

scala> val aa:String = "itcast"
aa: String = itcast
scala> println(aa)
itcast
scala> aa = "heima"
<console>:12: error: reassignment to val
       aa = "heima"
          ^

惰性赋值

功能：构建一个常量时不直接赋值，只构建常量对象，当用到数据内容时，再真正赋值

设计：避免值初始化以后，如果不被调用，占用内存，通过lazy使用时再进行初始化分配

语法:
lazy val 常量名称：数据类型 = 值

scala> val aa:String = "itcast"
aa: String = itcast
scala> lazy val bb:String = "heima"
bb: String = <lazy>
scala> println(aa)
itcast
scala> println(bb)
heima
scala> lazy var cc:String = "itcast"
<console>:1: error: lazy not allowed here. Only vals can be lazy
lazy var cc:String = "itcast"
    ^

注意：
惰性赋值只能用于常量，不能用于变量
在scala中推荐使用val常量，可以使用函数式编程解决变量的问题

字符串使用及插值表达式

#双引号定义
scala> val s1 = "itcast"
s1: String = itcast

scala> println(s1)
itcast
#三引号定义：用于比较长的字符串定义，可读性比较强
scala> val s2 = """
     | select xxxxx
     | from xxxx
     | where xxxx
     | """
s2: String =
"
select xxxxx
from xxxx
where xxxx

"
#字符串截取substring
scala> s1.substring(2)
res9: String = cast
scala> s1.substring(2,4)
res13: String = ca
#字符串替换replaceAll
scala> val s3 = "I like"
s3: String = I like

scala> s3.replaceAll(" ","-")
res14: String = I-like
#字符串拼接
scala> println(s3+" "+s1)
I like itcast

scala> s3 + " " + s1
res17: String = I like itcast

scala> s3.+(s1)
res18: String = I likeitcast

插值表达式的使用

功能：用于字符串拼接，可以在字符串中插入变量或者表达式
语法:
s"${变量 | 表达式}"

scala> s3 + " " + s1
res19: String = I like itcast

scala> s"${s3} ${s1}"
res20: String = I like itcast

scala> println(s"${s3.replaceAll(" ","-")}")
I-like

scala> println(s"${s3.replaceAll(" ","-")}-${s1}")
I-like-itcast

块表达式与if判断

基本与java一致

scala> if (c > 10){ false } else {true}
res27: Boolean = true

scala> if (c > 10) false else true
res28: Boolean = true

if(c > 10){
    println("c > 10")
}else if(c > 5){
    println("c > 5")
}else{
    println("c > 0")
}

for循环(守卫条件，推导式yield)

Scala中for循环的语法
语法：
for(i <- 集合/数值范围){
循环逻辑
}

scala> for(i <- 1 to 10) {println(i)}
1
2
3
4
5
6
7
8
9
10

守卫条件
功能：循环过程中实现数据过滤，增加循环条件，符合条件才会执行循环逻辑

• 优点：不是每次循环都会执行循环体，只有符合条件才执行循环体
• 语法
  for(x <- 集合/数值范围 守卫条件表达式){
  循环逻辑
  }
  

scala> for(i <- 1 to 10) {if(i % 2 == 0) {println(i)}} 
2
4
6
8
10

推导式yield

• 功能：在for循环后面加上表达式，针对循环的结果进行表达式的计算 ，计算结果组成一个新的集合
• 关键字：yield
• 语法
  for(i <- 集合/数值范围) yield {
  循环表达式
  //计算表达式
  }

 scala> for(i <- 1 to 10) yield {
       |    println(i)
       |    i*2
       | }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  res41: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

while循环

语法：
while(表达式){
符合条件的循环逻辑
}
do {
循环逻辑
} while( 表达式 );

scala> var a = 5
a: Int = 5

scala> while(a < 10){
     |     println(a)
     |     a = a + 1
     | }
5
6
7
8
9

scala> do{
     |     println(a)
     |     a = a + 1
     | }while(a < 10)
10

跳出循环Breaks

没有continue和break这两个关键字，但是不能使用这些关键字
Scala中的continue与break基于函数式编程的思想通过函数来实现
类：scala.util.control.Breaks
方法：break()
语法：当遇到break方法时，跳出当前breakable的代码块
导包：
import scala.util.control.Breaks._

import scala.util.control.Breaks._
  
  for(i <- 1 to 10){
      breakable{
         if(i == 5)  break()
         else println(i)
      }
  }