Scala学习笔记

一、简介

  scala是一门基于JVM的多范式编程语言

二、语法

1、语法格式

  1.1 var val

定义变量
val/var 变量标识：变量类型 = 初始值
eg：  var/val name:Sting = “Tom”

  1.2 使用类型推断来定义变量

Scala的语法要比Java简洁, 我们可以使用一种更简洁的方式来定义变量.
需求: 使用更简洁的语法定义一个变量, 保存一个人的名字"Tom"
scala> val name = "Tom"
name: String = Tom

  1.3 惰性赋值

当有一些变量保存的数据较大时, 但是不需要马上加载到JVM内存中, 就可以使用"惰性赋值"来提高效率.
		
语法格式:
	lazy val/var 变量名 = 表达式

2、字符串

  2.1 双引号

val/var 变量名 = "字符串值"

  2.2 插值

//Scala中, 可以使用插值表达式来定义字符串, 能有效避免大量字符串的拼接.
val/var 变量名 = s"${变量/表达式}字符串"

注意:                                                                            
	a) 在定义字符串之前添加 s                                           
	b) 在字符串中, 可以使用${}来引用变量或者编写表达式.      

  2.3 三引号

如果有大段的文本需要保存, 就可以使用三引号来定义字符串. 例如: 保存一大段的SQL语句, 三引号中间的所有字符串都将作为字符串的值.
eg：val sql = """select    
		  *                           
		from                         
		  t_user                    
		where                       
		  name = "zhangsan"
		"""			        		

3、数据类型与操作符

注意Scala类型与Java类型的不同:                                                 
	1) Scala中所有的类型都使用"大写字母"开头.                              
	2) 整形使用Int, 而不是Integer.                                                
	3) Scala中定义变量可以不写类型, 让Scala编译器自动推断.      

注意:                                                                                                                                                                                               
	1) Scala中没有++, --运算符                                                                                                                                                            
	2) 与Java不一样, 在Scala中, 可以直接使用==, !=进行比较, 它们与equals方法表示一致. 而比较两个对象的引用值, 使用 eq                                   

4、条件表达式（语法和java一样）

  4.1 有返回值的if

与java不一样的是
 在scala中，条件表达式也是有返回值的
 在scala中，没有三元表达式，可以使用if表达式替代三元表达式

val result = if（sex == “male”）1 else 0

  4.2 块表达式

在scala中，使用{}表示一个块表达式
和if表达式一样，块表达式也是有值的
值就是最后一个表达式的值


scala> val a = {
     | println("1 + 1")
     | 1 + 1
     | }

返回值是2

scala> val a = {
     | println("1 + 1")
     | 1 + 1
     | 3 + 4
     | }

返回值是7

5、循环

  5.1 for表达式

for(i <- 表达式/数组/集合) {
  // 表达式
}

1.to(10)  1到10

嵌套循环
for(i <- 1 to 3;j <- 1 to 5){
  //表达式
}


守卫(在for循环中加入了if)
for（i <- 表达式/数组/集合 if 表达式）{
 // 表达式
}

eg：
    // 添加守卫，打印能够整除3的数字
for(i <- 1 to 10 if i % 3 == 0) println(i)



for 推导式
将来可以使用for推导式生成一个集合
在for循环中，可以使用yield表达式构建出一个集合，我们把使用yield的表达式称为推导式

eg：生成一个10、20、30...100的集合
  for(i <- 1 to 10) yield i * 10

  5.2 while循环（必须是var的变量）

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

  5.3 break和continue

实现break  在for循环外
  导入break包 import scala.util.control.break
  使用breakable将for表达式包起来
  for表达式中需要退出循环的地方，添加`break()`方法调用
eg:
  breakable{
    for(i <- 1 to 100){
        if(i >= 50) break()
        else println(i)
     }
  }



实现continue  在for循环内
  for(i <- 1 to 100){
    breakable{
        if(i % 10 == 0) break()
        else println(i)
    }
  }

6、方法

  6.1 定义方法

def methodname(类型名：参数类型，类型名：参数类型) ： [return type] = {

  // 方法体
}

eg： 返回两个数的和
    def sum(a:Int,b:Int) = a + b

注意：
    - 参数列表的参数类型不能省略
    - 返回值类型可以省略，由scala编译器自动推断
    - 返回值可以不写return，默认就是{}块表达式的值
    
特别注意：
    - 定义递归方法，不能省略返回值类型

eg:
 def jc(i:Int) = {
    if(i<=1) 1
    else jc(i-1) * i
    }

  6.2 方法参数

- 默认参数
    // x，y带有默认值为0 
    def add(x:Int = 0, y:Int = 0) = x + y
    add()

- 带名参数 （在调用方法时，可以指定参数的名称来进行调用。）
    def add(x:Int = 0, y:Int = 0) = x + y
    add(1)
    返回的是 1 第一个参数会被覆盖
    add(y=1)
    返回的是 1 第二个参数会被覆盖

- 变长参数 （如果方法的参数是不固定的，可以定义一个方法的参数是变长参数）
    def 方法名(参数名：参数类型*) ：返回值类型 = {
        方法体
    }
 
eg：def add(num:Int*) = num.sum // 求和

  6.3 方法调用方式

- 后缀调用法
    对象名.方法名(参数)
    eg：Math.abs(-1)

- 中缀调用法
    对象名 方法名 参数
    eg：1 to 10     如果有多个参数，使用括号括起来
        Math abs -1

- 花括号调用法    // 方法只有一个参数，才能使用花括号调用法
    Math.abs{ 
        // 表达式1
        // 表达式2
    }   
    eg：Math.abs{-10}  

- 无括号调用法(如果方法没有参数，可以省略方法名后面的括号)
    eg:
        def m3()=println("hello")
        m3()

7、函数 

  7.1 定义函数

val 函数变量名 = (参数名:参数类型, 参数名:参数类型....) => 函数体

> - 函数是一个**对象**（变量）
> - 类似于方法，函数也有输入参数和返回值
> - 函数定义不需要使用`def`定义
> - 无需指定返回值类型

  7.2方法和函数的区别

- 方法是隶属于类或者对象的，在运行时，它是加载到JVM的方法区中
- 可以将函数对象赋值给一个变量，在运行时，它是加载到JVM的堆内存中
- 函数是一个对象，继承自FunctionN，函数对象有apply，curried，toString，tupled这些方法。方法则没有
- 方法无法复制给变量

  7.3 方法转换为函数

- 有时候需要将方法转换为函数，作为变量传递，就需要将方法转换为函数
- 使用` _`即可将方法转换为函数

eg：
    1. 定义一个方法用来进行两个数相加
    2. 将该方法转换为一个函数，赋值给变量
    def add(x:Int,y:Int)=x+y
    add: (x: Int, y: Int)Int

    scala> val a = add _
   

8、数组

  8.1 定长数组（长度不可以改变，元素可以改变）

// 通过指定长度定义数组
val/var 变量名 = new Array[元素类型](数组长度)

// 用元素直接初始化数组
val/var 变量名 = Array(元素1, 元素2, 元素3...)

使用`()`来获取元素和改变元素的值
    eg：变量名（下标）
获取长度
    数组名.length

  8.2 变长数组

- 创建变长数组，需要提前导入ArrayBuffer类`import scala.collection.mutable.ArrayBuffer

- 创建空的ArrayBuffer变长数组，语法结构：
      val/var a = ArrayBuffer[元素类型]()

- 创建带有初始元素的ArrayBuffer
      val/var a = ArrayBuffer(元素1，元素2，元素3....)


- 添加修改删除元素
    - 使用`+=`添加元素
        数组名 += 元素

    - 使用`-=`删除元素  同上

    - 使用`++=`追加一个数组到变长数组
        数组名 ++= Array(....)

  8.3 遍历数组

- 使用`for表达式`直接遍历数组中的元素
    for(i<- 数组名) println(i)

- 使用`索引`遍历数组中的元素
    1、for(i <- 0 to a.length - 1) println(a(i))
    2、for(i <- 0 until a.length) println(a(i))

    0 until n——生成一系列的数字，包含0，不包含n
    0 to n ——包含0，也包含n

  8.4 数组中的常用算法

- 求和——sum方法
- 求最大值——max方法
- 求最小值——min方法
- 排序——sorted方法  升序

用法：
    数组名.方法名   a.sum

9、元组 （元素是不可变的）

  9.1定义元组

- 元组可以用来包含一组不同类型的值。例如：姓名，年龄，性别，出生年月。元组的元素是不可变的。

- 使用括号来定义元组
    val/var 元组 = (元素1, 元素2, 元素3....)

- 使用箭头来定义元组（元组只有两个元素）
    val/var 元组 = 元素1->元素2

scala> val a = ("zhangsan", 20)
a: (String, Int) = (zhangsan,20)

scala> val a = "zhangsan" -> 20
a: (String, Int) = (zhangsan,20)

  9.2 访问元组

使用_1、_2、_3....来访问元组中的元素，_1表示访问第一个元素，依次类推

eg：
    val a = "zhangsan" -> "male"
    获取第一个元素
    a._1

10、列表（可以保存重复的值，有先后顺序）

  10.1 不可变列表

val/var 变量名 = List(元素1, 元素2, 元素3...)

  10.2 可变列表

可变列表就是列表的元素、长度都是可变的。
要使用可变列表，先要导入`import scala.collection.mutable.ListBuffer`

使用ListBuffer[元素类型]()创建空的可变列表，语法结构：
    val/var 变量名 = ListBuffer[Int]()

使用ListBuffer(元素1, 元素2, 元素3...)创建可变列表，语法结构：
    val/var 变量名 = ListBuffer(元素1，元素2，元素3...)

  10.3 可变列表的操作

- 获取元素（使用括号访问`(索引值)`）
    a.(0)

- 添加元素（`+=`）
    a += 元素

- 追加一个列表（`++=`）
    a ++= List(...)

- 更改元素（`使用括号获取元素，然后进行赋值`）

- 删除元素（`-=`）
    a -= 元素
- 转换为List（`toList`）
    a.toList

- 转换为Array（`toArray`）
    a.toArray

  10.4  列表常用操作

- 判断列表是否为空（`isEmpty`） 返回 boolean类型的值
- 拼接两个列表（`++`）
    列表1 ++ 列表2

- 获取列表的首个元素（`head`）和剩余部分(`tail`)
- 反转列表（`reverse`）
- 获取前缀（`take`）、获取后缀（`drop`）
    a.take(3)  返回前三个值
    a.drop(3)  返回除了前三个值以外的值

- 扁平化（`flaten`）
    扁平化表示将列表中的列表中的所有元素放到一个列表中。
    eg：
    - 有一个列表，列表中又包含三个列表，分别为：List(1,2)、List(3)、List(4,5)
    - 使用flatten将这个列表转换为List(1,2,3,4,5)

- 拉链（`zip`）和拉开（`unzip`）
    - 拉链：使用zip将两个列表，组合成一个元素为元组的列表
    - 拉开：将一个包含元组的列表，解开成包含两个列表的元组
    eg：
        val a = List("zhangsan", "lisi", "wangwu")
        val b = List(19, 20, 21)

        scala> a.zip(b)
        List[(String, Int)] = List((zhangsan,19), (lisi,20), (wangwu,21))

- 转换字符串（`toString`）
    toString方法可以返回List中的所有元素

- 生成字符串（`mkString`）
    val a = List(1,2,3,4)
    a.mkString
    String = 1234

    a.mkString(":")
    String = 1:2:3:4

以下三个的用法：列表名1.方法名(列表名2)
- 并集（`union`）
- 交集（`intersect`）
- 差集（`diff`）

11、Set（元素不重复 ，不保证插入顺序 ）

  11.1 不可变集

创建一个空的不可变集，语法格式：
val/var 变量名 = Set[类型]()

给定元素来创建一个不可变集，语法格式：
val/var 变量名 = Set(元素1, 元素2, 元素3...)


基本操作
- 获取集的大小（`size`）
- 遍历集（`和遍历数组一致`）
- 删除一个元素，生成一个Set（`-`）
- 拼接两个集，生成一个Set（`++`）
- 拼接集和列表，生成一个Set（`++`）

  11.2 可变集

import scala.collection.mutable.Set
val a = Set(...)

// 添加元素 +=
// 删除元素 -=

12、映射（由键值对组成的集合 ）

  12.1 不可变

val/var map = Map(键->值, 键->值, 键->值...)	// 推荐，可读性更好
val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)...)

- 根据key获取value
    map("key")

  12.2 可变 Map

定义语法与不可变Map一致。但定义可变Map需要手动导入`import scala.collection.mutable.Map

  12.3 基本操作

- 获取值(`map(key)`)
- 获取所有key（`map.keys`）
- 获取所有value（`map.values`）
- 遍历map集合
    for((x,y) <- map) println(s"$x $y")

- getOrElse
- 增加key,value对  '+'
    map + key->value

- 删除key '-'
    map - key

13、函数式编程

- 遍历（`foreach`）
    foreach(f: (A) ⇒ Unit): Unit
    eg:
        val a = List(1,2,3,4)
        a.foreach((x:Int)=>println(x))
        优化：a.foreach(x=>println(x))
        优化：a.foreach(println(_))   当函数参数，只在函数体中出现一次，而且函数体没有嵌套调用时，可以使用下划线来简化函数定义


- 映射（`map`） 就是一个将一种数据类型转换为另外一种数据类型的过程。
    def map[B](f: (A) ⇒ B): TraversableOnce[B]
    eg：
        a.map(x=>x+1)
        优化：a.map(_ + 1)

- 映射扁平化（`flatmap`）  理解为先map，然后再flatten
    def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): TraversableOnce[B]
    // 定义文本行列表
    scala> val a = List("hadoop hive spark flink flume", "kudu hbase sqoop storm")
    a: List[String] = List(hadoop hive spark flink flume, kudu hbase sqoop storm)

    // 使用map将文本行转换为单词数组
    scala> a.map(x=>x.split(" "))
    res5: List[Array[String]] = List(Array(hadoop, hive, spark, flink, flume),                 Array(kudu, hbase, sqoop, storm))

    // 扁平化，将数组中的
    scala> a.map(x=>x.split(" ")).flatten
    res6: List[String] = List(hadoop, hive, spark, flink, flume, kudu, hbase, sqoop, storm)



- 过滤（`filter`）
- 是否存在（`exists`）
- 排序（`sorted`、`sortBy`、`sortWith`）
- 分组（`groupBy`）
- 聚合计算（`reduce`）
- 折叠（`fold`）

三、类和对象

1、定义和访问成员变量

- 创建类
class 对象名(){}   // 如果类是空的 没有任何成员，可以省略{}   
                  // 如果构造器的参数是空的，可以省略()

- 创建对象
val 对象名 = new 类名()   // 创建对象可以省略括号

- 定义成员变量
1、完整的写法
    var 变量名：类型 = 初始值      var name:String = “”
2、使用下划线来初始化成员变量
    var 变量名：类型 = _           var name:String = _
3、可以省略类型，但是要赋值不能配合下划线使用
    var name = “”   

- 调用成员变量
    对象名.成员变量

- 成员变量赋值
    对象名.成员变量 = 值

- 定义成员方法
  def 方法名（参数列表）={
        方法体
    }
- 调用成员方法
    对象名.方法

2、访问修饰符

可以在成员前面添加private/protected关键字来控制成员的可见性。但在scala中，**`没有public关键字`**，任何没有被标为private或protected的成员都是公共的

3、类构造器（当创建类对象的时候，会自动调用类的构造器）

  3.1主构造器

- 定义语法
class 类名(var/val 参数名：类型 = 默认值，var/val 参数名：类型 = 默认值){
    // 构造代码块
}

- 注意
    1、构造器的参数列表是直接定义在类名后面，添加了val/var表示直接通过主构造器定义成员变量
    2、构造器参数列表可以指定默认值
    3、创建实例，调用构造器可以指定字段进行初始化
    4、整个class中除了**字段定义** 和 **方法定义**的代码都是构造代码
 
eg：
    1、给构造器传入参数    val zhangsan = new Person("张三", 20)
    2、不传入任何参数      val empty = new Person
    3、指定字段进行初始化    val man40 = new Person(age = 40)

3.2 辅助构造器（除了主构造器之外的构造器称为辅助构造器）

- 语法格式
    定义辅助构造器与定义方法一样，也使用`def`关键字来定义 
    定义在主构造器里面
    这个方法的名字为`this
    
    def this(参数名:类型, 参数名:类型) {
      // 第一行需要调用主构造器或者其他构造器
      // 构造器代码
    }



class Customer(var name: String = "", var address: String = "") {
    def this(arr: Array[String]) = {
      this(arr(0), arr(1))
    }
  }


  def main(args: Array[String]): Unit = {
    val zhansan = new Customer(Array("zhansan","beijing "))
    println(zhansan.name)
    println(zhansan.address)
  }

4、单例对象

  4.1 定义单例对象

- 定义单例对象和定义类很像，就是把class换成object
- 在object中定义的成员变量类似于Java的静态变量
- 可以使用object直接引用成员变量



object Demo {

  // 定义一个单例对象
  object Student {
    // 定义腿的数量
    val STUDENT_NUM = 67   变量的名字大写  这是规范
  }

  def main(args: Array[String]): Unit = {
    println(Student .STUDENT_NUM )
  }
}

  4.2 定义成员方法

- 在object中定义的成员方法类似于Java的静态方法

object Demo {

  object PrintUtil {

    // 打印分割线
    def printSpliter() = {
      // 字符串乘法，表示返回多少个字符串
      println("-" * 10)
    }
  }

  def main(args: Array[String]): Unit = {
    PrintUtil.printSpliter()
  }
}

5. 伴生对象

  5.1 定义伴生对象

- 伴生对象必须要和伴生类一样的名字
- 伴生对象和伴生类在同一个scala源文件中
- 伴生对象和伴生类可以互相访问private属性
- 如果某个成员的权限设置为private[this]，表示只能在当前类中访问。伴生对象也不可以访问
- 定义伴生对象就是把定义类的class换成object

  
  // 伴生类
  class CustomerService {
  }

  // CustomerService的伴生对象
  object CustomerService {
  }

5.2 apply方法

- 格式
object 伴生对象名 {
	def apply(参数名:参数类型, 参数名:参数类型...) = new 类(...)
}

6、继承

  6.1语法

class/object 子类 extends 父类 {
}

6.2 override和super

- 子类要覆盖父类中的一个方法，必须要使用override关键字
- 使用override来重写一个val字段
- 使用super关键字来访问父类的成员方法

7、类型判断

- isInstanceOf判断对象是否为指定类以及其子类的对象
- asInstanceOf将对象转换为指定类型

// 判断对象是否为指定类型
val trueOrFalse:Boolean = 对象.isInstanceOf[类型]
// 将对象转换为指定类型
val 变量 = 对象.asInstanceOf[类型]

8、抽象类

- 情况：
    1. 方法没有方法体（**抽象方法**）
    2. 变量没有初始化（**抽象字段**）

- 语法

// 定义抽象类
abstract class 抽象类名 {
  // 定义抽象字段
  val 抽象字段名:类型
  // 定义抽象方法
  def 方法名(参数:参数类型,参数:参数类型...):返回类型
}

9、特质(trait)

  9.1 定义

scala中没有Java中的接口（interface），替代的概念是——特质

- 定义
    trait 名称 {
        // 抽象字段
        // 抽象方法
    }

- 继承特质
 class 类 extends 特质1 with 特质2 {
    // 字段实现
    // 方法实现
 }
    

9.2 对象混入trait

scala中可以将trait混入到对象中，就是将trait中定义的方法、字段添加到一个对象中

-- 定义
    val/var 对象名 = new 类 with 特质

  trait Logger {
    def log(msg:String) = println(msg)
  }

  class UserService

  def main(args: Array[String]): Unit = {
    val service = new UserService with Logger
    service.log("混入的方法")
  }

9.3 trait调用链

类继承了多个trait后，可以依次调用多个trait中的同一个方法，只要让多个trait中的同一个方法在最后都依次执行super关键字即可。类中调用多个tait中都有这个方法时，首先会从最右边的trait方法开始执行，然后依次往左执行，形成一个调用链条。

9.4 trait的构造机制

- trait也有构造代码，但和类不一样，特质不能有构造器参数
- 每个特质只有一个无参数的构造器。
- 一个类继承另一个类、以及多个trait，当创建该类的实例时，它的构造顺序如下：
  1. 执行父类的构造器
  2. `从左到右`依次执行trait的构造器
  3. 如果trait有父trait，先构造父trait，如果多个trait有同样的父trait，则只初始化一次
  4. 执行子类构造器