（大数据开发随笔1）Scala编程语言基础——Scala编程基础

Scala编程基础

Scala简介

• 整合了面向对象编程和函数式编程
• 纯粹的面向对象语言
• 函数式语言

变量的定义、赋值

• val：不可变，声明时必须被初始化，不能再赋值

• var：可变，可以再次赋值

  val str = "hello world"
  val str2:String = "hello world"
  val i = 123
  val sum = 5 + 3
  val sum = (5).+(3)
  var price:double = 9.9
  

Lazy值（懒值）

• 特点：延时加载 —> Spark中的算子（API）：Transformation（延时加载），Action
• 该变量的初始化会被推迟，直到第一次使用该变量的时候

val x: Int = 10
lazy val y: Int = x + 1 //定义时不会计算y的值

函数

• 可以像定义变量一样定义函数，从而函数会有“值”，有“类型”，“值”就是“函数字面量”

• 函数参数类型：

  • 默认参数：赋予默认值
  • 带名参数：func(参数名=参数)
  • 可变参数：def func(args: Int*) = args

• 参数的求值策略

  • call by value：对函数的实参求值，并且只求一次（无论函数内部使用该参数与否，都会在传入时对该参数求值）
  • call by name：函数的实参在函数体内部，每次调用都会求值（仅当在函数内部使用该参数时，才会对该参数进行求值）

• 传统定义方式：def counter(value:Int):Int = {value += 1}

• 上面定义的函数的类型是：(Int)=>Int，有一个参数时括号可省略

• 去掉定义中的类型声明部分就是“值”：(value) => {value += 1}

• 对比变量的声明：val num:Int = 5，函数的定义可以写为：val counter:Int=>Int = {value => value += 1}

• 匿名函数：(num:Int) => num * 2，放入变量：val fun:Int=>Int = (num:int) => num * 2

• 特定条件下可以省略返回类型：val fun = (num:Int) => num * 2，此时num的类型不能省略

• 带着返回类型可以省略参数类型：val fun: Int=>Int = (num) => num * 2

• 当函数的每个参数在函数字面量内仅出现一次，可省略=>用_代替参数

  > val counter = (_:Int) + 1 // 等价于 x:Int => x + 1
  > val add = (_:Int) + (_:Int) // 等价于 (a:Int, b:Int) => a + b
  
  > val m1 = List(1, 2, 3)
  > m1.map(_*2) // 等价于 m1.map(x => x * 2)
  List(2, 4, 6)
  

异常：Exception

• 抛出异常：throw

  • 举例：throw new Exception("Some Error Happened")

• 捕获异常：try-catch-finally

  try{
      val words = scala.io.Source.fromFile("//D:/test.txt").mkString // 读取文件
  }catch {
      case ex1: java.io.FileNotFoundException => {
          println('File Not Found')
      }
      case ex2: IllegalArgumentException => {
          println("IllegalArgumentException")
      }
      case _: Exception => {
          println("Other Exception")
      }
  }finally {
      println("****Finally Block ***")
  }
  
  

数组Array

• 一种可变的、可索引的、元素具有相同类型的数据集合

• 与Java最大的区别：Java --> [] ; Scala --> ()

• 类型：定长数组、变长数组

• 下标从0开始

  val intArr = new Array[Int](3) //定长数组
  intArr(0) = 12
  intArr(1) = 24
  intArr(2) = 5
  
  val strArr = new Array[String](5)
  val sArr = Array("haha", "xixi")
  
  val d = new ArrayBuffer[Int]() //变长数组
  d += 1 // 向数组中添加元素
  d += (10, 20, 30)
  d.trimEnd(2) // 去掉最后两元素
  d.toArray // 变长转定长
  
  d.foreach(println) // 类似python的map
  
  // 常见数组操作
  val myArray = Array(1, 23, 10, 5, 8, 3)
  myArray.max
  myArray.min
  myArray.sum
  
  // 排序 Array.sortWith((Int, Int) => Boolean)
  myArray.sortWith((a, b) => {
      if (a > b) true
      else false
  }) // 降序
  // 简写
  myArray.sortWith(_ > _)
  
  // 多维数组
  val myMatrix = Array.ofDim[Int](3,4)
  

映射

• 一个Map集合，由<key value>组成

• 使用->来创建：val scores = Map("Tom"->80, "Mary"->90)

• 类型：不可变、可变

  val scores = Map("Tom"->80, "Mary"->90) // 不可变，默认为immutable
  val chinese = scala.collection.mutable.Map("Tom"->80, "Mary"->90) // 可变
  val chinese2 = scala.collection.mutable.Map(("Tom", 80), ("Mary", 90)) // 同上
  
  // 基本操作
  chinese("Mary") // 取值，不存在则抛出异常
  chinese.contains("Mary") // 判断是否存在
  chinese.getOrElse("Mary", -1) // 存在则返回value，不存在则返回-1
  chinese.foreach(println)
  

元组

• 对多个不同类型对象的封装

• 下标从1开始

• val t1 = new Tuple3("bigdata", 234, 9.99) // Tuple3表示有3个元素
  val t2 = ("bigdata", 234, 9.99)
  // 访问
  t2._1
  t2._2
  t1.productIterator.foreach(println) // 遍历，需要借助迭代器
  

List

• 一种共享相同类型的不可变的对象序列

• 一旦被定义，其值就不能改变，因此声明List时必须初始化

• var strList = List("bigdata", "hadoop", "spark")
  strList.head // "bigdata"
  strList.tail // ("hadoop", "spark")
  
  val otherList = "apache"::strList
  val intList = 1::2::3::Nil // Nil为空列表对象