Scala语言基础

1. Scala语言的特点

　　a. 多范式编程语言，面向对象(抽象、封装)和函数式(过程、结果)编程

　　b. 代码简洁 ==>可读性较差

　　c. 代码会被变异成Java字节码，运行在JVM上

2. Scala语言基础

　　a. 变量修饰符

　　var ：修饰的变量在整个生命周期内可被重新赋值

　　val ：类似于java中的final，初始化后不能被重新赋值

　　* 当修饰符作用于集合类型时，修饰的是类型，可理解为仅限定集合类型的引用是否可变，并不限制集合中的值是否可变。

　　b. 基本数据类型

　　(1) 数值类型：Byte，Short，Int，Long，Float，Double；

　　　　Byte:  8位有符号数字，从-128 到 127

　　　　Short: 16位有符号数据，从-32768 到 32767

　　　　Int：  32位有符号数据

　　　　Long： 64位有符号数据　　

　　* scala中任何数据都是对象，1可以看成是Int对象

scala> 1+1
res0: Int = 2

scala> 1.+(1)
res1: Int = 2

　　(2)字符类型和字符串类型：Char和String

　　对于字符串，在Scala中可以进行插值操作。

scala> val name = "beichen"
name: String = beichen

scala> s"Username : ${name}"
res2: String = Username : beichen

　　(3)Unit类型：相当于Java中的void类型

　　(4)Nothing类型：一般表示在执行过程中，产生了Exception

　　c.类型修饰符

　　：修饰数据类型，scala可自动推导数据类型，不用显示指定　　

scala> val name : String = "beichen"
name: String = beichen

scala> val name = "beichen"
name: String = beichen

　　d. scala的循环

　　(1)　for循环

　　使用 <- 提取符访问集合中的元素

scala> for(i <- 0 until 5){
     | print(i + " ")
     | }
0 1 2 3 4

　　0 until 5　生成整型集合，不包含5 Rangescala.collection.immutable.Range = Range(0, 1, 2, 3, 4)

　　0 to 5 包含5

　　yield关键字用于for循环中可以产生一个新的集合　　

  val names = List("beichen", "scala")
  var upperNames = for{
    s <- names
    s1 = s.toUpperCase()
  }  yield s1
  upperNames.foreach(println)

　　* 使用yield时for循环的循环条件必须写在大括号内；foreach为集合类型的高级函数，可以接受参数为函数的参数。

　　(2)wihle & do while与java类似

　　* 区别在于break的用法，scala中break使用前需要使用导入 import util.control.Breaks._ 并使用 breakable将需要break的代码段包裹起来　　

import util.control.Breaks._
  val names = List("beichen", "scala")
  var j = 0;
  breakable{
    while(j < names.length){
      if(j % 2 == 1)break()
    }
  }

　　e. scala中函数的参数　　

• 有两种函数参数的求值策略

　　 (x: Int)Call By Value：对函数实参求值，且仅求一次

　　 (x: => Int)Call By Name：函数实参每次在函数体内被用到时都会求值

　　

　　

• 默认参数：定义参数时赋默认值
• 代名参数：访问多参数函数时，可指定参数名称确定传入的参数值
• 可变 参数：参数后面加* 标识多个同类型参数

　　f. Scala的Lazy值（懒值）:当val被申明为lazy时，它的初始化将被推迟，直到我们首次对它取值。

　　可对应于Spark中的Transformation和Action算子进行理解，Transformation算子类似于lazy机制，不触发计算。

　　定义时在前面加上lazy如： lazy val x:Int = 10

　　g.scala中的异常处理，用法与java类似，catch部分使用模式匹配　　

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

object Test {
   def main(args: Array[String]) {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException =>{
            println("Missing file exception")
         }
         case ex: IOException => {
            println("IO Exception")
         }
      }
   }
}

　　h.scala中的集合

　　(1)数组，定长数组Array与变长数组ArrayBuffer　　

val a = new Array[Int](10)
val b = new ArrayBuffer[Int]()

　　(2)映射　　

scala> var scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
scores: scala.collection.immutable.Map[String,Int] = Map(Alice -> 10, Bob -> 3,Cindy -> 8)

scala> scores += ("beichen" -> 9)

　　*此处scores是不可变Map，由于用var修饰，+=添加元素后返回的是新Map

scala> val scores = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
scores: scala.collection.mutable.Map[String,Int] = Map(Bob -> 3, Alice -> 10, Cindy -> 8)

scala> scores += ("beichen" -> 9)
res13: scores.type = Map(Bob -> 3, Alice -> 10, beichen -> 9, Cindy -> 8)

　　*此处是可变Map，直接向其中添加元素

　　(3) 元组(Tuple)：用于表示不同数据类型的集合，可以取代java中使用JavaBean进行的数据封装，简化开发

scala> val t1 = ("beichen", 175, 65)
t1: (String, Int, Int) = (beichen,175,65)

scala> t1._2
res16: Int = 175

　　*元组中元素可以使用._访问，下标从1开始。