一, 簡單入門

1.1 為什么要學習Scala?

1. Java的擴展和延伸

   • Scala基于JVM, 和Java完全兼容, 同樣具有跨平臺,可以執行好,方便的垃圾回收等特性;
   • Scala是一種純粹的面向物件語言;
   • Scala是一門函式式編程語言;

2. Scala更適合大資料的處理

   • Scala對集合型別資料處理有非常好的支持
   • Sparkd的底層用Scla撰寫

1.2 Scala 與 Java, JVM的關系

1.3 Scala語言的特點

1.4 Scala 安裝和IDE的配置

1. 安裝和配置環境變數: 參考本文
2. 在IDEA中配置Scala插件: 參考本文

1.5 HelloWorld 案例

具體撰寫程序

object HelloWorld{
    //定義方法 main ==        def 方法名(引數名: 引數型別):回傳值 ={}
    def mian(args: Array[String]): unit={
        println("Hello World!!")
    }
}

1.6 對反編譯Scala位元組碼檔案的解讀

待補充

1.7 Scala 中的 Object和Class

待補充

二, 變數和資料型別

2.1 注釋

Scala的注釋使用和Java 完全相同

//  	1.單行注釋

/* */ 	2. 多行注釋

/** 	3. 檔案注釋
*
**/

2.2 Scala 的變數和常量

常量: 在程式執行的程序中, 值不會改變的變數

1. Java中的變數和常量語法

• 變數型別 變數名 = 值, int a = 10;
• final 常量型別 常量名 = 值, final int b = 20;

2. Scala中的變數和常量

注意:

1. 宣告變數時, 型別可以忽略, 編譯器自動推導, 即型別推導;
2. 型別確定后, 就不能修改, 說明Scala是強資料型別語言;
3. 變數宣告時, 必須要有初始值;
4. 在宣告/定義一個變數時, 可以使用var/val修飾, var修飾的變數可改變, val修飾的變數不可改;

[案例一, 變數宣告和賦值]

1. 型別自動推導;
2. 強型別語言;
3. 宣告變數時必須賦值;
4. val的值不可變, var可變;

object TestValAndVar {

  //1. 型別推導; 宣告變數時, 型別可以忽略, 編譯器會自動推導;
  var a1 = 10;
  var a2:Int = 10;
  var b3 = "areusb?";
  val c5 = false;

  //2. 強型別語言; 變數/常量的資料型別確定后, 就不能再修改
  var e3:Int = 250;
  e3 = "feswgf"; //編譯器不會對此句報錯, 執行時才會報錯 type mismatch, 看下圖

  //3. 宣告變數時必須有初始值;
  var e4:Int; // 抱錯如下圖所示

  //4. var可變, va不可變
  var f4 = 6;
  f4 = 9;

  val f5 = 100;
  f5 = 200; //編譯器當場報錯;
  def main(args : Array[String]): Unit = {
     println(a1 + b3  + e4)

  }
}

[案例二, var, val 在物件修改上的不同]

1. var修飾的物件參考可以直接改變;
2. val修飾的物件參考不可以改變, 但是物件的狀態(參考的值)可以改變;

2.2 識別符號

• Scala 對各種變數、方法、函式等命名時使用的字符序列稱為識別符號，即：凡是自己可以起名字的地方都叫識別符號，

命名規則:
1. 字符,下劃線,$開頭, 后接字母,數字,下劃線;
2. 以運算子開頭, 且只包含運算子(+ - * / # ! 等 的任意組合)
3. 用反引號 ``包括的任意字串, 即便是Scala關鍵字也可以這樣作為識別符號;

第一點跟Java命名規則是一致的, 下面2,3條簡直是絕了, 聞所未聞的;

[案例: 分辨識別符號正確與否]

• h-b不對, 是_ 這種叫下劃線, 沒有-這一說
• x h, 識別符號中不能存在空格
• Int, 保留字不行, 加上``反引號倒是可以
• 有運算子的話, 就只能全是運算子, 所以 +*-/#!1 不對
• if 不對, 保留字

2.3 字串

1. 基本語法

1. 字串, 通過+號連接;
2. printf用法: 格式化字串, 通過%傳值;
3. 字串模板(插值字串): 通過$獲取變數值;

object TestString {
  def main(args: Array[String]): Unit = {
    //1. + 字串拼接,  另外, *是多次拼接字串
    var str1:String = "Hello !"
    var str2:String = "Are u sb?"

    println("'+'拼接字串, "+str1 + str2)

    println(str1*3) //Hello !Hello !Hello !

    //2. printf, 格式化字串.
    // %d  整數, %s 字串 , %f 輸出浮點數
    var name = "liming"
    var age = 18
    var grade = 88.26

    printf("this is %s, and his age is %d , he got %2.3f in math exam;", name,age,grade)
    println()

    //3. 插值字串(模板字串),
    // 3.1 插值字串的寫法:  println(s"... ${變數名} ")
    //3.2 如何填入變數值呢?  ${變數名}, 插值就體現在這里

    //1. 典型的插值字串,  println(s"待輸入的字串,  插入變數寫為 ${變數名}")
    println(s"${name} is my friend, his math got ${grade}, which is so so but better than me")

    //2. 格式化的插值字串, println(f"  ${變數名}%d"),
    // %%d  整數, %s 字串 , %f 輸出浮點數等等
    println(f"this is a 格式化字串, 比如: ${grade}%2.6f")

    //3. 按照我們給定的字串格式列印輸出字串, println(raw" ");
    println(raw"我用了個    空格, %d本來是格式化字串(輸出整數), 使用了raw 原樣輸出了, ${name}, 但是插值還是能用的")

    //4. 三引號, 保持多行字串的原始格式輸出
    var ss = s"""
       |我這個可是
       |多行字串輸出噢, 甭管你是任何的
       |格式化字串, %d, %f, %u, 不管你, 但是
       |插值還是可以用的噢
       |""".stripMargin
    println(ss)
  }
}

拓展: Java中printf的用法

2.4 Scala鍵盤輸入, 檔案讀寫初探

• 語法:
  • StdIn.readLine() 讀取字串
  • StdIn.readShort() 讀取Short型別的值
  • StdIn.readDouble() 讀取Double型別的值
  • …

[案例: 鍵盤輸入, 檔案讀寫]

import java.io.{File, FileWriter}
import scala.io.{Source, StdIn}

object TestInAndOut {
  def main(args: Array[String]): Unit = {
    //讀取字串
    println("請輸入姓名: ")
    val name: String = StdIn.readLine()

    println("請輸入年齡: ")
    val age: Int = StdIn.readInt()

    println(s"You are ${age}, your name is ${name}")

    //讀檔案, Source.fromFile(path).foreach(print)
    Source.fromFile("D:\\Code\\IdeaWorkSpace\\scala_demo\\src\\main\\resources\\read.txt").foreach(print)

    //寫檔案, Scala寫檔案借助的還是Java 的IO流
    val writer = new FileWriter(new File("D:\\Code\\IdeaWorkSpace\\scala_demo\\src\\main\\resources\\writeRes.txt"))
    
    val outStr: String = "\"Scala讀檔案, Source.fromFile(path).foreach(print)\"";
    
    writer.write(outStr)
    writer.close()
  }
}

2.5 Scala 資料型別

1. Java中的資料型別

• Java 資料型別詳解, 參見此文: Java基礎必會語法復習

2. Scala中的資料型別

2.5.1 Unit, Null, Nothing 型別

|資料型別|描述|
|Unit| 表示無值, 和其他語言中的void等同, 用作不回傳任何結果的方法的結果型別; Unit只有一個實體值, 寫成()|
|Null| null, Null型別只有一個實體值null|
|Nothing|Nothing型別處于Scala的類層級最底端, 他是任何其他型別的子型別; 當一個函式, 我們確定沒有正常的回傳值, 可以用Nothing來指定回傳型別, 這樣有一個好處, 就是我們可以把回傳的值(例外)賦給其他的函式或者變數(兼容性)|

[案例]

1. Unit 型別

• 用來標識程序, 也就是沒有明確回傳值的函式

為什么把Unit型別的方法列印輸出是一對括號()? Unit原始碼分析:

2. Null類

• 只有一個實體值,即null, 表示空參考
• Null類似于Java中的null參考.
• Null類可以賦值給任意參考型別(AnyRef), 但是不能賦值給值型別(AnyVal)

3. Nothing

• 沒有任何實體物件;
• 作為沒有正常回傳值的方法的回傳型別, Nothing可以告訴你, 這個方法不會正常回傳;
• 而且由于Nothing是其他任意型別的子類, 他還能跟要求回傳值的方法兼容;

• 擴展閱讀: 理解Scala語言中Null/Nothing/Nil/None/Unit的區別

2.5.2 Scala 資料型別轉換

Scala和Java 的資料型別轉換是一致的,

1. 資料從精度小的(資料型別表示范圍小的)-->精度大的(資料型別表示范圍大的), 會進行自動型別轉換(隱式轉換);
2. 相反, 由大 --> 小, 必須進行手動強制型別轉換 xx.toInt

2.5.2.1 隱式轉換

• Java, Scala 的自動轉換

1. 自動提升原則: 有多重型別的資料混合運算時, 系統首先將所有資料轉換成精度大的那種資料型別, 然后再進行計算;
2. 把精度大的數值型別復制給精度較小的數值型別時, 就會報錯, 反之就會進行自動型別轉換;
3. (Byte, Short)這倆各自和 char之間不會相互自動轉換
4. 但是,Byte, Short, Char他們三者可以組合就散, 在計算時首先會自動轉為Int型別;

2.5.2.2 強制型別轉換

2.5.2.3 數值型別和 String型別之間的轉換

實際的編程中, 經常能用到數值和字串之間的互轉, 來我們回憶下在Java中是怎樣實作數值和字串互轉的:

1. 數值==>字串, 會用到String類的包裝方法, String.valueOf(數值變數)
2. 字串==> 數值, 根據數值對應的資料型別的不同, 數值的包裝類.parse數值(數值變數), 比如, Integer.parseInt(intval)

那么, Scala是怎么進行轉換的呢?

1. 數值==>字串, 直接使用 +""拼接,
2. 字串==> 數值, 根據數值的資料型別不同, (s1.toInt, s1.toByte, s1.toLong, s1.toShort)

var n5:Int = “12.6”.toInt 會出現 NumberFormatException 例外，

來看一道面試題:(待補充)

三, 運算子

Scala 運算子的使用和 Java 運算子的使用基本相同，只有個別細節上不同，

3.1 算術運算子

3.2 關系運算子

Java和Scala中 == 和 equals()的異同點:

在Java中,

1. 對于基本資料型別, ==是用來比較值的大小是否相等, 而對于參考資料型別, ==用來比較參考的地址值是否相等;
2. 另外, equals()作為Object類的方法, 通常是用來比較兩個參考資料的地址是否相等, 然而在String, Integer, Date類中對equals()進行了重寫, 用來比較兩個值是否相等;

---

在Scala中,

1. 由于Scala中的資料型別全是參考資料型別, 也就相對沒有Java那么令人凌亂了, ==和 equals() 都是用來比較兩個變數的值是否相等
2. 而Scala用什么比較參考地址值? Scala使用單獨的一個 eq() 來比較兩個物件的參考地址

object HelloWorld {
    def main (args: Array[String]): Unit= {
      //1. 比較值是否相等, ==或equals()
      val num1: Int = 2
      val num2: Int = 2

      val str1: String = "liming"
      val str2: String = "liming"

      println("Scala使用 ==或quals() 來比較兩個變數的值是否相等: ")
      println("num1 和 num2 相等嗎? " + (num1 == num2))
      println("num1 和 num2 相等嗎? " + (num1.equals(num2)))

      println("str1 和 str2 相等嗎? " + (str1 == str2))
      println("str1 和 str2 相等嗎? " + (str1.equals(str2)))
      
      //2. 比較參考是否相等
      println("=========================================")

      println("Scala使用 eq()  比較兩個變數參考的地址值是否相等")
      println("num1 和 num2 的地址相等嗎? " + (str1.eq(str2)))
    }
}

3.3 賦值運算子

3.4 位運算子

• 位運算子是一種比較底層的計算方式,
• 按位左移, << , 移動n位, 就是把原數x2ⁿ
• 按位右移, >> , 移動m位, 就是把原數/2^{m, 除不盡的話就直接保留整數, 舍棄小數點;}

Scala 運算子的本質(方法)

四, 流程控制

4.1 分支控制 if-else

分支控制讓程式有選擇的執行, 分支控制有三種: 單分支, 雙分析, 多分支

1. Scala中的分支控制邏輯基本與Java一致, 但是最大的不同在于, Scala中的 if else{} 運算式是有回傳值的,

• 具體回傳值內容取決于滿足條件的分支代碼體中的最后一行內容,
• 如果是一個字串"", 那么就回傳這一行字串, 如果是一個變數, 或一個輸出陳述句, 就回傳()

2. 注意: scala中if else運算式是有回傳值的，且默認回傳型別是Any型別，在根據實際回傳的數值進行推斷，如果if或者else回傳的型別不一樣，就回傳Any型別（所有型別的公共超型別），

3. Java中的三元運算子可以用if else 實作

• Java的三元運算子: 判斷條件 ? 條件為true的執行內容 : 條件為false的執行內容
• Scala的三元運算子: if(判斷條件) 條件為true的執行內容 else 條件為false的執行內容

4.2 嵌套分支

(就上面的if-else 套娃唄, 沒啥可講的)

4.3 Switch 分支 (無, 使用模式匹配處理, 后面補充)

4.4 For 回圈控制

Scala也為for回圈這一常見的控制結構提供了非常多的特性, 這些for回圈的特性被稱為for推導式或for運算式;

4.4.1 范圍資料回圈(to)–> 左閉右閉

[基本用法]

// 把[0,10]的每一個整數, 回圈賦值給i
for(i <- 0 to 10){
  print(i + " ")
}

// 0 to 10 等同于 0.to(10),  to就是方法噢

• i表示回圈變數, to表示的是回圈從0到10(包括10)

如何倒序遍歷? 加個reverse即可;

for(i <- 0 to 10){
  print(i + " ")
}

4.4.2 范圍資料回圈(Until)–> 左閉右開

[基本用法]

// 把[0,10)的每一個整數, 回圈賦值給i
for(i <- 0 until 10){
  print(i + " ")
}

//或者使用下面這種方式, Range(a,b)
for(i <- Range(0,10)){
  print(i + " ")
}

• i表示回圈變數, until表示的是回圈從0到10(不包括10)

4.4.3 回圈守衛( if xx)

• 回圈守衛, 即回圈保護式(或條件判斷, 守衛)
• 保護式為true則進入回圈體內部, 為false則跳過本次回圈, 類似于continue

[基本用法]

for(i <- 1 to 3 if i != 2){
  print(i + " ")
}

• 上面的寫法等同于:

for(i <- 1 to 3){
   if (i != 2){
      print(i + " ")
   }
}

4.4.4 回圈步長(by)

[基本用法]

// 步長為2的回圈遍歷
// 注意噢, 步長不能為 0, 可以為正, 負, 浮點數(可能會精度出錯)
for (i <- 0 to 10 by 2) {
println("i=" + i)
}

4.4.4 嵌套回圈(多重回圈)

[案例一, 九九乘法表]

object NineNideMultiple {
  def main(args: Array[String]): Unit = {
    //九九乘法表
    //外層回圈遍歷1 to 9, 內層回圈 i * (1 - > 9)

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

4.4.6 引入變數

4.4.7 回圈回傳值

4.5 While 和 do…While 回圈控制

Scala中的While, do…While回圈和Java中的用法完全一致

• 與 for 陳述句不同，while 陳述句沒有回傳值，即整個 while 陳述句的結果是 Unit 型別()

4.6 回圈中斷

Scala內置控制結構去掉了break和continue, 是為了更好的適應函式式編程, 推薦使用函式式的風格解決break和continue的功能, 而不是一個關鍵字.
Scala 中使用breakable 控制結構來實作break和continue功能

需求 1：采用例外的方式退出回圈

def main(args: Array[String]): Unit = {
  try {
    for (elem <- 1 to 10) {
      println(elem)
      if (elem == 5) throw new RuntimeException
    }
  }catch {
    //模式匹配
    case e: Exception =>   //啥都不做. 退出回圈
    }
  println("正常結束回圈")

需求 2：采用 Scala 自帶的函式，退出回圈

import scala.util.control.Breaks
def main(args: Array[String]): Unit = {
    Breaks.breakable(
    for (elem <- 1 to 10) {
println(elem)
if (elem == 5) Breaks.break()
}
)
println("正常結束回圈")
}

需求 3：對 break 進行省略

import scala.util.control.Breaks._
object TestBreak {
def main(args: Array[String]): Unit = {
breakable {
for (elem <- 1 to 10) {
println(elem)
if (elem == 5) break
}
}
println("正常結束回圈")
}
}

需求 4：回圈遍歷 10 以內的所有資料，奇數列印，偶數跳過（continue）

object TestBreak {
def main(args: Array[String]): Unit = {
for (elem <- 1 to 10) {
if (elem % 2 == 1) {
println(elem)
} else {
println("continue")
}
}
}
}