Scala知識點

一變量和數據類型

數據類型

Scala是完全面向對象的語言，只有任意值對象（AnyVal）和任意引用對象（AnyRef）

類型轉換

強制類型轉換

var a : Int = 10
Var b : Byte = a.toByte

二流程控制

for循環

1，基本語法

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for ( i <- Range(1,5) ) { // 範圍集合
            println("i = " + i )
        }
        for ( i <- 1 to 5 ) { // 包含5
            println("i = " + i )
        }
        for ( i <- 1 until 5 ) { // 不包含5
            println("i = " + i )
        }
    }
}

2，循環守衛

for (i <- Range(1,9) if i !=2){
  println("i="+i)
}

3，步長

for(i <- Range(1,5,2)){
  println("i="+i)
}
for(i <- 1 to 10 by 2){
  println("i="+i)
}

4，返回值
scala所有的表達式都有返回值，for循環要返回具體值，需要使用關鍵字yield

循環中斷

scala.util.control.Breaks.breakable(
      for(i <- 1 to 5){
        if(i==3){
          scala.util.control.Breaks.break()
        }
        println(i)
      }
    )

三函數式編程

面向對象編程：
分解對象，行爲，屬性，然後通過對象的關係以及行爲的調用來解決問題
函數式編程：
將問題分解成一個一個步驟，將每個步驟封裝，通過調用這些封裝好的步驟，解決問題

基本語法

[修飾符] def 函數名 ( 參數列表 ) [:返回值類型] = {
    函數體
}

private def test( s : String ) : Unit = {
    println(s)
}

函數至簡原則

1，省略return關鍵字

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun1(): String = {
            return "zhangsan"
        }
        def fun11(): String = {
            "zhangsan"
        }
    }
}

2，省略花括號

當代碼只有一行的時候

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun2(): String = "zhangsan"
    }
}

3，省略返回值類型

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun3() = "zhangsan"
    }
}

4，省略參數列表

沒有參數的時候，調用的時候不能使用小括號

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun4 = "zhangsan"
    }
}

5, 省略等號
6，省略名稱和關鍵字

沒def和函數名叫匿名函數，需要一個變量賦值才能使用
過程函數：沒有返回值類型和等號的函數

val s = () => {println("cat is ugly")}
    s()

四高階函數編程

1，函數作爲值

變函數的結構賦值給變量，可以是使用下劃線，也可以使用 String=>String

object ScalaOut {
  def main(args: Array[String]): Unit = {

    def fun1(): Unit ={
      "cat is ugly!"
    }
    val a = fun1
    val b = fun1 _
    // val b:String=>String = fun1
    println(a)
    println(b)
  }
}

2，函數作爲參數

（參數列表）=> 返回值

object ScalaOut {
  def main(args: Array[String]): Unit = {

    def first(i:Int,j:Int): Int ={
      i * j * 2
    }
    def second(f:(Int,Int)=>Int): Int ={
      f(10,20)
    }

    println(second(first))
  }
}

3，函數作爲返回值

object ScalaOut {
  def main(args: Array[String]): Unit = {

    def first(i:Int,j:Int): Int ={
      i * j * 2
    }
    def second() ={
      first _
    }

    val  s = second()
    println(s(10,30))
    println(second()(10,20))
  }
}

4，匿名函數

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun4( f:Int => Int ): Int = {
            f(10)
        }
        println(fun4((x:Int)=>{x * 20}))
        println(fun4((x)=>{x * 20}))
        println(fun4((x)=>x * 20))
        println(fun4(x=>x * 20))
        println(fun4(_ * 20))
    }
}

5，閉包

我們的一個變量在函數執行完後被其他的函數包含使用，改變了這個變量的聲明週期
一個函數使用了外部的變量，但外部的變量不能被回收調，包含在當前函數形成閉合的效果，稱之爲比閉包。
形成的條件：嵌套函數的使用就有閉包；將函數複製給變量來使用

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun5() = {
            val i = 20
            def fun55() = {
                i * 2
            }
            fun55 _
        }
    }
}

6，函數柯里化
將複雜的函數參數列表變得簡單化
將多個參數的參數列表變成多個參數列表

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun6(i:Int)(j:Int) = {
            i * j
        }
    }
}

7.控制抽象

將函數作爲參數，但是這個函數沒有輸入參數，也無需返回結果

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun7(op: => Unit) = {
            op
        }
        fun7{
            println("xx")
        }
    }
}

8，遞歸函數

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun8(j:Int):Int = {
            if ( j <= 1 ) {
                1
            } else {
                j * fun8(j-1)
            }
        }
        println(fun8(5))
    }
}

9，惰性函數
函數的執行將推遲，直到我們首次對此取值

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun9(): String = {
            println("function...")
            "zhangsan"
        }
        lazy val a = fun9()
        println("----------")
        println(a)
    }
}

五面向對象編程

基礎面向對象編程

1 包

基本的語法和java的package包語法一致
擴展語法

Scala中的包和類的物理路徑沒有關係
package關鍵字可以嵌套聲明使用
子包可以直接訪問父包內容
package也可以看作對象

2導入

Scala中基本的import導入語法與Java完全一致
import java.util._
// Scala中使用下劃線代替Java中的星號
擴展語法：

import語法可以在任意位置使用
可以導包，不是導類
一行可以導多個類
可以屏蔽某個包中的類

import java.util._
import java.sql.{ Date=>_, Array=>_, _ }

給類起別名，簡化使用
可以使用類的絕對路徑而不是相對路徑

3 類和屬性

Scala中的屬性其實在編譯後也是方法

4 構造方法

class User() { // 主構造函數
    var username : String = _ 
    def this( name:String ) { // 輔助構造函數
        this() // 輔助構造函數應該直接或間接調用主構造函數
        username = name
}
def this( name:String, password:String ) {
    this(name) // 構造器調用其他另外的構造器，要求被調用構造器必須提前聲明
}
}

高階面向對象編程

1 繼承

和Java一樣，Scala的繼承也是單繼承，使用extends關鍵字

class Person {
}
class User extends Person {
}

封裝

把抽象的數據和對數據的操作封裝在一起，數據保護在內部，通過調用來訪問

抽象

將一個不完整的類稱爲抽象類
如果一個方法只有聲明而沒有實現，那麼是抽象方法
屬性只有聲明沒有初始化，爲抽象屬性
子類繼承父類，必須實現抽象方法或者補全抽象屬性，否則也爲抽象

單例對象

指定類的對象只能創建一個
伴生對象本身就是單例對象

如果方法名交apply方法，那麼就可以省略方法名稱
構造對象的兩種方式：
使用new 關鍵字，等同於調用類的構造方法
使用伴生對象構造對象，等同於調用伴生對象的apply方法（不能省略參數列表）

class User { // 伴生類
}
object User { // 伴生對象
    def apply() = new User() // 構造伴生類對象
}
...
val user1 = new User()// 通過構造方法創建對象
val user2 = User() // 通過伴生對象構建伴生類對象

特質

將多個類相同特徵剝離出來，形成一個獨立的語法結構
trait：特質，可以看成是抽象類或者是接口
*OCP原則：開閉原則（擴展開發，修改關閉）

動態混入

object ScalaTrait{
    def main(args: Array[String]): Unit = {
        val mysql = new MySQL with Operator
        mysql.insert()
    }
}
trait Operator {
    def insert(): Unit = {
        println("insert data...")
    }
}
class MySQL {

}

擴展

1 類型檢查

class Person{
}
object Person {
    def main(args: Array[String]): Unit = {

        val person = new Person

        //（1）判斷對象是否爲某個類型的實例
        val bool: Boolean = person.isInstanceOf[Person]

        if ( bool ) {
            //（2）將對象轉換爲某個類型的實例
            val p1: Person = person.asInstanceOf[Person]
            println(p1)
        }

        //（3）獲取類的信息
        val pClass: Class[Person] = classOf[Person]
        println(pClass)
    }
}

2 枚舉和應用類

object Test {
    def main(args: Array[String]): Unit = {
        println(Color.RED)
    }
}

// 枚舉類
object Color extends Enumeration {
    val RED = Value(1, "red")
    val YELLOW = Value(2, "yellow")
    val BLUE = Value(3, "blue")
}

// 應用類
object AppTest extends App {
    println("application");
}

3 type定義新類型

相當於重命名類型名

object Test {
    def main(args: Array[String]): Unit = {
        type S =String
        var v : S = "abc"
    }
}

六集合

有三大類：序列Seq，集合Set，映射Map

1 數組

1.1，不可變數組（Array）

基本語法

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        //（1）數組定義
        val arr01 = new Array[Int](4)
        println(arr01.length) // 4

        //（2）數組賦值
        //（2.1）修改某個元素的值
        arr01(3) = 10
        val i = 10
        arr01(i/3) = 20
        //（2.2）採用方法的形式修改數組的值
        arr01.update(0,1)

        //（3）遍歷數組
        //（3.1）查看數組
        println(arr01.mkString(","))

        //（3.2）普通遍歷
        for (i <- arr01) {
            println(i)
        }

        //（3.3）簡化遍歷
        def printx(elem:Int): Unit = {
            println(elem)
        }
        arr01.foreach(printx)
        arr01.foreach((x)=>{println(x)})
        arr01.foreach(println(_))
        arr01.foreach(println)
    }
}

基本操作
如果運算符使用冒號結尾，那麼運算規則爲從右向左

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        // 創建數組的另外一種方式
        val arr1 = Array(1,2,3,4)
        val arr2 = Array(5,6,7,8)
        // 添加數組元素，創建新數組
        val arr3: Array[Int] = arr1 :+ 5
        println( arr1 == arr3 ) // false

        val arr4: Array[Int] = arr1 ++: arr2
        // 添加集合
        val arr5: Array[Int] = arr1 ++ arr2

        arr4.foreach(println)
        println("****************")
        arr5.foreach(println)
        println("****************")
        // 多維數組
        var myMatrix = Array.ofDim[Int](3,3)
        myMatrix.foreach(list=>list.foreach(println))
        // 合併數組
        val arr6: Array[Int] = Array.concat(arr1, arr2)
        arr6.foreach(println)

        // 創建指定範圍的數組
        val arr7: Array[Int] = Array.range(0,2)
        arr7.foreach(println)
    }
}

1.2 可變數組（ArrayBuffer）

import scala.collection.mutable.ArrayBuffer
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val buffer = new ArrayBuffer[Int]
        // 增加數據
        buffer.append(1,2,3,4)
        // 修改數據
        buffer.update(0,5)
        buffer(1) = 6
        // 刪除數據
        val i: Int = buffer.remove(2)
        buffer.remove(2,2)
        // 查詢數據
        println(buffer(3))
        // 循環集合
        for ( i <- buffer ) {
            println(i)
        }
    }
}

基本操作：

import scala.collection.mutable.ArrayBuffer
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val buffer1 = ArrayBuffer(1,2,3,4)
        val buffer2 = ArrayBuffer(5,6,7,8)

        val buffer3: ArrayBuffer[Int] = buffer1 += 5
        println( buffer1 eq buffer3 ) // true

        // 使用 ++ 運算符會產生新的集合數組
        val buffer4: ArrayBuffer[Int] = buffer1 ++ buffer2
        // 使用 ++= 運算符會更新之前的集合，不會產生新的數組
        val buffer5: ArrayBuffer[Int] = buffer1 ++= buffer2
        println( buffer1 eq buffer4 ) // false
        println( buffer1 eq buffer5 ) // true
    }
}

可變數組和不可變數組的轉換

// 將不可變數組轉換爲可變數組
val buffer1: mutable.Buffer[Int] = array.toBuffer
// 將可變數組轉換爲不可變數組
val array1: Array[Int] = buffer.toArray

2 Seq集合

2.1 不可變List

基本語法：

object ScalaCollection{
    def main(args: Array[String]): Unit = {

        // Seq集合
        val list = List(1,2,3,4)

        // 增加數據
        val list1: List[Int] = list :+ 1
        println(list1 eq list)
        list1.foreach(println)
        val list2: List[Int] = 1 +: list
        list2.foreach(println)
        println("*****************")
        val list3: List[Int] = list.updated(1,5)
        println(list eq list3)
        List3.foreach(println)
    }
}

基本操作：

object ScalaCollection{
    def main(args: Array[String]): Unit = {

        // Seq集合
        val list1 = List(1,2,3,4)
        // 空集合
        val list2: List[Nothing] = List()
        val nil  = Nil
        println(list2 eq nil)

        // 創建集合
        val list3: List[Int]  = 1::2::3::Nil
        val list4: List[Int] = list1 ::: Nil

        // 連接集合
        val list5: List[Int] = List.concat(list3, list4)
        list5.foreach(println)

        // 創建一個指定重複數量的元素列表
        val list6: List[String] = List.fill[String](3)("a")
        list6.foreach(println)
    }
}

2.2 可變List（ListBuffer）

基本語法：

import scala.collection.mutable.ListBuffer
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        // 可變集合
        val buffer = new ListBuffer[Int]()
        // 增加數據
        buffer.append(1,2,3,4)
        // 修改數據
        buffer.update(1,3)
        // 刪除數據
        buffer.remove(2)
        buffer.remove(2,2)
        // 獲取數據
        println(buffer(1))
        // 遍歷集合
        buffer.foreach(println)
    }
}

基本操作：

import scala.collection.mutable.ListBuffer
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        
        // 可變集合
        val buffer1 = ListBuffer(1,2,3,4)
        val buffer2 = ListBuffer(5,6,7,8)

        // 增加數據
        val buffer3: ListBuffer[Int] = buffer1 :+ 5
        val buffer4: ListBuffer[Int] = buffer1 += 5
        val buffer5: ListBuffer[Int] = buffer1 ++ buffer2
        val buffer6: ListBuffer[Int] = buffer1 ++= buffer2

        println( buffer5 eq buffer1 )
        println( buffer6 eq buffer1 )

        val buffer7: ListBuffer[Int] = buffer1 - 2
        val buffer8: ListBuffer[Int] = buffer1 -= 2
        println( buffer7 eq buffer1 )
        println( buffer8 eq buffer1 )
    }
}

轉換：

import scala.collection.mutable
import scala.collection.mutable.ListBuffer
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val buffer = ListBuffer(1,2,3,4)
        val list = List(5,6,7,8)
 
        // 可變集合轉變爲不可變集合
        val list1: List[Int] = buffer.toList
        // 不可變集合轉變爲可變集合
        val buffer1: mutable.Buffer[Int] = list.toBuffer
    }
}

3 Set集合

3.1 不可變Set

基本語法：

object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val set1 = Set(1,2,3,4)
        val set2 = Set(5,6,7,8)

        // 增加數據
        val set3: Set[Int] = set1 + 5 + 6
        val set4: Set[Int] = set1.+(6,7,8)
        println( set1 eq set3 ) // false
        println( set1 eq set4 ) // false
        set4.foreach(println)
        // 刪除數據
        val set5: Set[Int] = set1 - 2 - 3
        set5.foreach(println)

        val set6: Set[Int] = set1 ++ set2
        set6.foreach(println)
        println("********")
        val set7: Set[Int] = set2 ++: set1
        set7.foreach(println)
        println(set6 eq set7)
    }
}

基本操作

object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val set1 = Set(1,2,3,4)
        val set2 = Set(5,6,7,8)

        // 增加數據
        val set3: Set[Int] = set1 + 5 + 6
        val set4: Set[Int] = set1.+(6,7,8)
        println( set1 eq set3 ) // false
        println( set1 eq set4 ) // false
        set4.foreach(println)
        // 刪除數據
        val set5: Set[Int] = set1 - 2 - 3
        set5.foreach(println)

        val set6: Set[Int] = set1 ++ set2
        set6.foreach(println)
        println("********")
        val set7: Set[Int] = set2 ++: set1
        set7.foreach(println)
        println(set6 eq set7)
    }
}

3.2 可變Set

基本語法

import scala.collection.mutable
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val set1 = mutable.Set(1,2,3,4)
        val set2 = mutable.Set(5,6,7,8)

        // 增加數據
        set1.add(5)
        // 添加數據
        set1.update(6,true)
        println(set1.mkString(","))
        // 刪除數據
        set1.update(3,false)
        println(set1.mkString(","))

        // 刪除數據
        set1.remove(2)
        println(set1.mkString(","))

        // 遍歷數據
        set1.foreach(println)
    }
}

基本操作

import scala.collection.mutable
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val set1 = mutable.Set(1,2,3,4)
        val set2 = mutable.Set(4,5,6,7)

        // 交集
        val set3: mutable.Set[Int] = set1 & set2
        println(set3.mkString(","))
        // 差集
        val set4: mutable.Set[Int] = set1 &~ set2
        println(set4.mkString(","))
    }
}

4 Map集合

4.1 不可變Map

基本語法

object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val map1 = Map( "a" -> 1, "b" -> 2, "c" -> 3 )
        val map2 = Map( "d" -> 4, "e" -> 5, "f" -> 6 )

        // 添加數據
        val map3 = map1 + ("d" -> 4)
        println(map1 eq map3) // false

        // 刪除數據
        val map4 = map3 - "d"
        println(map4.mkString(","))

        val map5: Map[String, Int] = map1 ++ map2
        println(map5 eq map1)
        println(map5.mkString(","))

        val map6: Map[String, Int] = map1 ++: map2
        println(map6 eq map1)
        println(map6.mkString(","))

        // 修改數據
        val map7: Map[String, Int] = map1.updated("b", 5)
        println(map7.mkString(","))

        // 遍歷數據
        map1.foreach(println)
    }
}

4.2 不可變Map

基本語法

import scala.collection.mutable
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val map1 = mutable.Map( "a" -> 1, "b" -> 2, "c" -> 3 )
        val map2 = mutable.Map( "d" -> 4, "e" -> 5, "f" -> 6 )

        // 添加數據
        map1.put("d", 4)
        val map3: mutable.Map[String, Int] = map1 + ("e" -> 4)
        println(map1 eq map3)
        val map4: mutable.Map[String, Int] = map1 += ("e" -> 5)
        println(map1 eq map4)

        // 修改數據
        map1.update("e",8)
        map1("e") = 8

        // 刪除數據
        map1.remove("e")
        val map5: mutable.Map[String, Int] = map1 - "e"
        println(map1 eq map5)
        val map6: mutable.Map[String, Int] = map1 -= "e"
        println(map1 eq map6)
        // 清除集合
        map1.clear()
    }
}

基本操作

import scala.collection.mutable
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val map1 = mutable.Map( "a" -> 1, "b" -> 2, "c" -> 3 )
        val map2 = mutable.Map( "d" -> 4, "e" -> 5, "f" -> 6 )

        val set: Set[(String, Int)] = map1.toSet
        val list: List[(String, Int)] = map1.toList
        val seq: Seq[(String, Int)] = map1.toSeq
        val array: Array[(String, Int)] = map1.toArray

        println(set.mkString(","))
        println(list.mkString(","))
        println(seq.mkString(","))
        println(array.mkString(","))

        println(map1.get("a"))
        println(map1.getOrElse("a", 0))

        println(map1.keys)
        println(map1.keySet)
        println(map1.keysIterator)
        println(map1.values)
        println(map1.valuesIterator)
    }
}

七元組

將多個無關的數據元素封裝爲一個整體，最多能容納22個

object ScalaCollection{
    def main(args: Array[String]): Unit = {

        // 創建元組
        val tuple = (1, "zhangsan", 30)

        // 根據順序號訪問元組的數據
        println(tuple._1)
        println(tuple._2)
        println(tuple._3)
        // 迭代器
        val iterator: Iterator[Any] = tuple.productIterator

        // 根據索引訪問元素
        tuple.productElement(0)
        // 獲取整體
        println(tuple.x)

        // 如果元組的元素只有兩個，那麼我們稱之爲對偶元組，也稱之爲鍵值對
        val kv: (String, Int) = ("a", 1)
        val kv1: (String, Int) = "a" -> 1
        println( kv eq kv1 )
    }
}

八隊列

進隊：enqueue
出隊：dequeue

import scala.collection.mutable
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val que = new mutable.Queue[String]()
        // 添加元素
        que.enqueue("a", "b", "c")
        val que1: mutable.Queue[String] = que += "d"
        println(que eq que1)
        // 獲取元素
        println(que.dequeue())
        println(que.dequeue())
        println(que.dequeue())
    }
}

九並行

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val result1 = (0 to 100).map{x => Thread.currentThread.getName}
        val result2 = (0 to 100).par.map{x => Thread.currentThread.getName}

        println(result1)
        println(result2)
    }
}

十常用方法

1 常用方法

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val list = List(1,2,3,4)

        // 集合長度
        println("size =>" + list.size)
        println("length =>" + list.length)
        // 判斷集合是否爲空
        println("isEmpty =>" + list.isEmpty)
        // 集合迭代器
        println("iterator =>" + list.iterator)
        // 循環遍歷集合
        list.foreach(println)
        // 將集合轉換爲字符串
        println("mkString =>" + list.mkString(","))
        // 判斷集合中是否包含某個元素
        println("contains =>" + list.contains(2))
        // 取集合的前幾個元素
        println("take =>" + list.take(2))
        // 取集合的後幾個元素
        println("takeRight =>" + list.takeRight(2))
        // 查找元素
        println("find =>" + list.find(x => x % 2== 0))
        // 丟棄前幾個元素
        println("drop =>" + list.drop(2))
        // 丟棄後幾個元素
        println("dropRight =>" + list.dropRight(2))
        // 反轉集合
        println("reverse =>" + list.reverse)
        // 去重
        println("distinct =>" + list.distinct)
    }
}

2衍生集合

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val list = List(1,2,3,4)
        val list1 = List(3,4,5,6)

        // 集合頭
        println("head => " + list.head)
        // 集合尾
        println("tail => " + list.tail)
        // 集合尾迭代
        println("tails => " + list.tails)
        // 集合初始化
        println("init => " + list.init)
        // 集合初始化迭代
        println("inits => " + list.inits)
        // 集合最後元素
        println("last => " + list.last)
        // 集合並集
        println("union => " + list.union(list1))
        // 集合交集
        println("intersect => " + list.intersect(list1))
        // 集合差集
        println("diff => " + list.diff(list1))
        // 切分集合
        println("splitAt => " + list.splitAt(2))
        // 滾動
        println("sliding => " + list.sliding(2))
        // 滑動
        println("sliding => " + list.sliding(2,2))
        // 拉鍊
        println("zip => " + list.zip(list1))
        // 數據索引拉鍊
        println("zipWithIndex => " + list.zipWithIndex)
    }
}

3 計算函數

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val list = List(1,2,3,4)
        val list1 = List(3,4,5,6)

        // 集合最小值
        println("min => " + list.min)
        // 集合最大值
        println("max => " + list.max)
        // 集合求和
        println("sum => " + list.sum)
        // 集合乘積
        println("product => " + list.product)
        // 集合簡化規約
        println("reduce => " + list.reduce((x:Int,y:Int)=>{x+y}))
        println("reduce => " + list.reduce((x,y)=>{x+y}))
        println("reduce => " + list.reduce((x,y)=>x+y))
        println("reduce => " + list.reduce(_+_))
        // 集合簡化規約(左)
        println("reduceLeft => " + list.reduceLeft(_+_))
        // 集合簡化規約(右)
        println("reduceRight => " + list.reduceRight(_+_))
        // 集合摺疊
        println("fold => " + list.fold(0)(_+_))
        // 集合摺疊(左)
        println("foldLeft => " + list.foldLeft(0)(_+_))
        // 集合摺疊(右)
        println("foldRight => " + list.foldRight(0)(_+_))
        // 集合掃描
        println("scan => " + list.scan(0)(_+_))
        // 集合掃描(左)
        println("scanLeft => " + list.scanLeft(0)(_+_))
        // 集合掃描(右)
        println("scanRight => " + list.scanRight(0)(_+_))
    }
}

4 功能函數

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val list = List(1,2,3,4)

        // 集合映射
        println("map => " + list.map(x=>{x*2}))
        println("map => " + list.map(x=>x*2))
        println("map => " + list.map(_*2))
        // 集合扁平化
        val list1 = List(
            List(1,2),
            List(3,4)
        )
        println("flatten =>" + list1.flatten)
        // 集合扁平映射
        println("flatMap =>" + list1.flatMap(list=>list))
        // 集合過濾數據
        println("filter =>" + list.filter(_%2 == 0))
        // 集合分組數據
        println("groupBy =>" + list.groupBy(_%2))
        // 集合排序
        println("sortBy =>" + list.sortBy(num=>num)(Ordering.Int.reverse))
        println("sortWith =>" + list.sortWith((left, right) => {left < right}))
    }
}

十一案例實操（WordCount）

object ScalaWordCount{
    def main(args: Array[String]): Unit = {

        val list: List[String] = Source.fromFile("d:\user.json").getLines().toList

        val wordList: List[String] = list.flatMap(_.split(" "))

        val word2OneList: List[(String, Int)] = wordList.map((_,1))

        val word2ListMap: Map[String, List[(String, Int)]] = word2OneList.groupBy(_._1)

        val word2CountMap: Map[String, Int] = word2ListMap.map(
            kv => {
                (kv._1, kv._2.size)
            }
        )
        println(word2CountMap)
    }
}

十二模式匹配

執行匹配語句，所有的case都不匹配，執行case _分支

object ScalaMatch{
    def main(args: Array[String]): Unit = {
        var a: Int = 10
        var b: Int = 20
        var operator: Char = '+'
        var result = operator match {
            case '+' => a + b
            case '-' => a - b
            case '*' => a * b
            case '/' => a / b
            case _ => "illegal"
        }
        println(result)
    }
}

十三應用場景

變量應用

object ScalaMatch { 
    def main(args: Array[String]): Unit = {
        val (x, y) = (1, 2)
        println(s"x=$x,y=$y")

        val Array(first, second, _*) = Array(1, 7, 2, 9)
        println(s"first=$first,second=$second")

        val Person(name, age) = Person("zhangsan", 16)
        println(s"name=$name,age=$age")
    }
    case class Person(name: String, age: Int)
}

循環匹配

object ScalaMatch {
    def main(args: Array[String]): Unit = {
        val map = Map("A" -> 1, "B" -> 0, "C" -> 3)
        for ((k, v) <- map) { //直接將map中的k-v遍歷出來
            println(k + " -> " + v) //3個
        }
        println("----------------------")
        //遍歷value=0的 k-v ,如果v不是0,過濾
        for ((k, 0) <- map) {
            println(k + " --> " + 0) // B->0
        }
        println("----------------------")
        //if v == 0 是一個過濾的條件
        for ((k, v) <- map if v >= 1) {
            println(k + " ---> " + v) // A->1 和 c->33
        }
    }
}

函數參數

object ScalaMatch {
    def main(args: Array[String]): Unit = {
        val list = List(
            ("a", 1), ("b", 2), ("c", 3)
        )
        val list1 = list.map {
            case ( k, v ) => {
                (k, v*2)
            }
        }
        println(list1)
    }
}

偏函數

對數據進行篩選，符號條件的數據纔會進行相應的處理

List(1, 2, 3, 4, 5, 6, "test").collect { case x: Int => x + 1 }.foreach(println)

異常

object ScalaException {
    def main(args: Array[String]): Unit = {
        try {
            var n= 10 / 0
        }catch {
            case ex: ArithmeticException=>{
                // 發生算術異常
                println("發生算術異常")
            }
            case ex: Exception=>{
                // 對異常處理
                println("發生了異常1")
                println("發生了異常2")
            }
        }finally {
            println("finally")
        }
    }
}

隱式轉換

泛型

正則表達式

基本語法

object ScalaRegex {
    def main(args: Array[String]): Unit = {
        // 構建正則表達式
        val pattern = "Scala".r
        val str = "Scala is Scalable Language"

        // 匹配字符串 - 第一個
        println(pattern findFirstIn str)

        // 匹配字符串 - 所有
        val iterator: Regex.MatchIterator = pattern findAllIn str
        while ( iterator.hasNext ) {
            println(iterator.next())
        }

        println("***************************")
        // 匹配規則：大寫，小寫都可
        val pattern1 = new Regex("(S|s)cala")
        val str1 = "Scala is scalable Language"
        println((pattern1 findAllIn str1).mkString(","))
    }
}

一 變量和數據類型

數據類型

類型轉換

二 流程控制

for循環

循環中斷

三 函數式編程

基本語法

函數至簡原則

四 高階函數編程

五 面向對象編程

基礎面向對象編程

1 包

2導入

3 類和屬性

4 構造方法

高階面向對象編程

1 繼承

封裝

抽象

單例對象

特質

擴展

六 集合

1 數組

1.1，不可變數組（Array）

1.2 可變數組（ArrayBuffer）

2 Seq集合

2.1 不可變List

2.2 可變List（ListBuffer）

3 Set集合

3.1 不可變Set

3.2 可變Set

4 Map集合

4.1 不可變Map

4.2 不可變Map

七 元組

八 隊列

九 並行

十 常用方法

1 常用方法

2衍生集合

3 計算函數

4 功能函數

十一 案例實操（WordCount）

十二 模式匹配

十三 應用場景

變量應用

循環匹配

函數參數

偏函數

異常

隱式轉換

泛型

正則表達式

基本語法

一變量和數據類型

二流程控制

三函數式編程

四高階函數編程

五面向對象編程

六集合

七元組

八隊列

九並行

十常用方法

十一案例實操（WordCount）

十二模式匹配

十三應用場景