Scala從入門到入土(從入門到放棄)

1 Scala介紹

Scala是一門 綜合了 面向物件的 函式式編程的 基于JVm的 語言

特點:
1 語法簡潔
2 開發速度快 , 運行速度快
3 兼容 Java 可以訪問Java類別庫
4 很多大資料框架的原始碼或編程介面都支持Scala
5 使用廣泛 國際認可

2 Scala運行環境

運行環境: JDK 8 或者11(長期支持)
ScalaSDK 2.12.11 穩定(或者2.12.12)

3 Scala 基礎語法

3.1 宣告變數 語法詳解

1 Scala陳述句最后不要加分號
2 Scala中型別可以可以省略,因為Scala編譯器 支持型別判斷
3 val修飾的修飾的變數不能重新賦值 (類似于Java中的final)
4 var可以重新賦值
5 開發中 常用val
6 可以使用type給型別起別名
7 可以使用lazy修飾變數,延遲變數的初始化

測驗: type 給型別起別名 可以用數字嗎??? (針對6)
答: 不可以

3.2 資料型別

Any 父類( 類似Java中的 Object )
值型別 Scala中的值型別都是大寫開頭
Byte
Short
Int
Long
Double
Float
Boolean
Char

String: 定義方式1: " "
定義方式2: “”" 這里面可以寫SQL “”"
定義方式3: 字串拼接可以使用插值運算式
定義方式4: 插值運算式 加 “”" “”"

3.3 運算子

語法詳解
Scala中的+ - * / %等運算子的作用與Java一樣，
位運算子 & | ^ >> <<也一樣，
注意：
1.Scala中的運算子實際上是方法
2.Scala中沒有++、–運算子，需要通過+=、-=來實作同樣的效果
3.+ - * / %是方法，那么就可以進行運算子多載，完成特殊的運算
(也就是自己在類中定義+ - * / %方法表示特殊的運算)

3.4 塊運算式

定義變數時可以使用 {} 包含一系列運算式，其中{}塊的最后一個運算式的值就是整個塊運算式的值，

3.5條件運算式 :

cala條件運算式的語法和Java一樣，只是更加簡潔，且Scala中if else運算式是有回傳值的

注意：
Scala中沒有三元運算式,如果if或者else回傳的型別不一樣，就回傳Any型別,對于沒有回傳值的，使用Unit，寫做()，相當于java中的void

3.6回圈運算式:

在scala中，可以使用for回圈和while回圈，但一般推薦使用for運算式，因為for運算式語法更簡潔

● 簡單for回圈：

for (變數 <- 運算式/陣列/集合) {回圈體}
for(i <- 1 to 10) println(i) 

● 嵌套for回圈

	for (變數1 <- 運算式/陣列/集合; 變數2 <- 運算式/陣列/集合) {回圈體}
	for(i <- 1 to 9; j <- 1 to 9){
	      if(i >= j ) print(s"${j} * ${i} = ${j*i}")
	      if(j == 9) println()
	    }

● 守衛
for運算式中，可以添加if判斷陳述句，這個if判斷就稱之為守衛，我們可以使用守衛讓for運算式更簡潔，

	for(i <- 運算式/陣列/集合 if 運算式) {回圈體}
	for(i <- 1 to 10 if i % 3 == 0) println(i)

● for推導式
在for回圈體中，可以使用yield運算式構建出一個集合，我們把使用yield的for運算式稱之為推導式,即可以使用for推導式生成一個新的集合（一組資料）

	//該for運算式會構建出一個集合
	val l = for(i <- 1 to 10) yield i * 10

● 注意：
while陳述句本身沒有值，即整個while陳述句的結果是Unit型別的()

	var n = 1;
	val result = while(n <= 10){
	  n += 1
	}
	println(result) //()
	println(n)  //10

3.7 break和continue

Scala中沒有break和continue 關鍵字來退出回圈,如果需要使用break/continue，可以使用scala.util.control.Breaks物件的breakable和break方法，

4 方法

Scala中的方法和Java中的方法一樣,都是用來封裝某些功能的,他可以接收引數,并在方法體中進行一些處理操作,最后還可以回傳處理的結果

定義格式:

 def 方法名(引數名1: 引數型別1, 引數名2: 引數型別2) : 回傳型別 = {方法體}

語法細節:
1.方法的回傳值型別和return可以不寫，編譯器可以自動推斷出來
2.對于遞回方法，必須指定回傳型別
3.如果方法沒有回傳值，回傳Unit型別(類似于void，也可以不寫)
4.回傳值型別有多種情況則回傳Any
5.帶有默認值引數的方法，呼叫時，可以給定新值，也可以使用默認值
6.可以通過引數名來指定傳遞給哪一個引數，
這樣傳遞引數時就可以不按照順序傳遞
7.方法沒有引數，呼叫時可以省略()，如果定義時()省略，呼叫時則必須省略
8.可變參使用 變數名:型別* （類似Java的…）

5 函式

函式的本質是: 物件
(函式就和方法都是用來封裝一些操作的)

格式

●完整語法:

val函式名稱:(引數型別)=>函式回傳值型別=(引數名稱:引數型別)=>{函式體}

●簡寫語法:

val函式名稱=(引數名稱:引數型別)=>{函式體}//如果只有一行{}可以省略

●符號解釋

=  表示將右邊的函式賦給左邊的變數
=> 左面表示輸入引數名稱和型別，右邊表示函式的實作和回傳值型別

證明Scala中的函式本質也是物件

●注意:
嚴格的來說，函式與方法是不同的東西，定義方式上也有很多的區別,但是在Scala中，函式本身是物件，方法可以通過下劃線_轉換為函式，

6 集合

集合分類
分類方式

一: 按照集合資料結構分類

Seq序列
Set
Map

二: 按照可變不可變進行分類

不可變集合  scala.collection.immutable (默認)
    開發時建議Scala優先采用不可變集合 默認即為不可變
可變集合  scala.collection.

陣列 Array

●不可變/定長陣列：
 	val/var 變數名= new Array[T](陣列長度)
	val/var 變數名 = Array(元素1, 元素2, 元素3...)

●可變/變長陣列：
	//需要匯入import scala.collection.mutable.ArrayBuffer包
	val/var 變數名 = ArrayBuffer[T]() 
	val/var 變數名 = ArrayBuffer(元素1, 元素2, 元素3...)

list

●不可變串列(默認) 	
import scala.collection.immutable._

創建方式1.使用List(元素1, 元素2, 元素3, ...)來創建一個不可變串列
    val/var 變數名 = List(元素1, 元素2, 元素3...)

創建方式2.使用::方法創建一個不可變串列
    val/var 變數名 = 元素1 :: 元素2 :: Nil
注意:
	使用::拼接方式來創建串列，必須在最后添加一個Nil

●可變串列 		
import scala.collection.mutable._
創建方式1.使用ListBuffer[元素型別]()創建空的可變串列
    val/var 變數名 = ListBuffer[Int]()

創建方式2.使用ListBuffer(元素1, 元素2, 元素3...)創建可變串列
    val/var 變數名 = ListBuffer(元素1，元素2，元素3...)

Set

●Set說明
	Set代表一個沒有重復元素的無序集合；
	即無法加入重復元素且不保證插入順序的，

●不可變Set(默認) 		
	import scala.collection.immutable._
	
	1.創建一個空的不可變集，語法格式：
	    val/var 變數名 = Set[型別]()
	    
	2.給定元素來創建一個不可變集，語法格式：
	    val/var 變數名 = Set(元素1, 元素2, 元素3...)

●可變Set 		
	import scala.collection.mutable._
	格式相同，導包不同
	
	注意:在main方法里導包是導包下面的集合是可變的
		在首行導包是main方法中的全部 set都是可變的
	val/var 變數名 = Set[型別]()

Tuple 元組

1．語法詳解
元組也是可以理解為一個容器，可以用來存放各種相同或不同型別的資料，
例如：姓名，年齡，性別，出生年月，
元組的元素是不可變的，

●創建元組
方式一:使用括號來定義元組

	val/var 元組 = (元素1, 元素2, 元素3....)

方式二:使用箭頭來定義元組（元組只有兩個元素）

	al/var 元組 = 元素1->元素2 //對偶/二元組是最簡單的元組(k,v)

注意:如果定義二元組使用方式一/二都可以 但是如果是三元組,則需要注意只能用方式2

●獲取元組中的值

	使用下劃線加腳標 ，例如 tuple._1  tuple._2  tuple._3

注意：元組中的元素腳標是從1開始的

●將對偶(二元組)組成的陣列轉換成映射(映射就相當于Java中的Map)

將對偶/二元組的集合轉換成映射： 呼叫其toMap 方法

●遍歷
可以呼叫元組的productIterator方法獲取迭代器物件進行遍歷

2．拉鏈操作：

使用zip將多個值系結在一起，如果兩個陣列的元素個數不一致，拉鏈操作后生成的陣列的長度為較小的那個陣列的元素個數, 使用zipAll將多個值系結在一起，缺少的用默認的元素填充

Map Map是多個二元組
在Scala中，把哈希表這種資料結構叫做映射，類比Java的map集合

●不可變Map

import scala.collection.immutable.Map
	格式一：  使用箭頭     
  	val/var map = Map(鍵->值, 鍵->值, 鍵->值...)	  	// 推薦，可讀性更好
  	
	 格式二：利用元組
 	 val/var map = Map((鍵, 值), (鍵, 值), (鍵, 值), (鍵, 值)...)

●可變Map

import scala.collection.mutable.Map
//與 不可變Map 格式相同，導包不同

●獲取值

map(鍵)
map.getOrElse(鍵,默認值)

●修改值

map(鍵)=值

Queue

佇列資料存取符合先進先出的策略,有 scala.collection.mutable.Queue 和 scala.collection.immutable.Queue ,一般來說我們在開發中佇列通常使用可變佇列

●常見操作

			+= //追加
			enqueue //入隊
			dequeue //出隊

代碼

	package cn.itcast.collection
  /**
    * Author caowei
    * Date 2019/7/3 20:16
    * Desc 
    */
  object QueueDemo {
    def main(args: Array[String]): Unit = {
      //佇列的創建
      import scala.collection.mutable.Queue
      val q1 = new Queue[Int]
      println(q1) //Queue()
      //佇列元素的追加
      q1 += 1;
      println(q1)//Queue(1)
      //向佇列中追加List
      q1 ++= List(2, 3, 4)
      println(q1)//Queue(1, 2, 3, 4)
      //按照進入佇列的順序洗掉元素
      q1.dequeue()
      println(q1)//Queue(2, 3, 4)
      //塞入資料
      q1.enqueue(9, 8, 7)
      println(q1)//Queue(2, 3, 4, 9, 8, 7)
      //回傳佇列的第一個元素
      println(q1.head)//2
      //回傳佇列最后一個元素
      println(q1.last)//7
      //回傳除了第一個以外的元素
      println(q1.tail)//Queue(3, 4, 9, 8, 7)
    }
  }

今日分享這么多, 僅代表個人理解 , 有借鑒部分 有任何疑問或者侵權問題 歡迎咨詢 QQ 2211572344 交流探討