Scala進階之路-Scala的基本語法

　　　　　　　　　　　　Scala進階之路-Scala的基本語法

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正傑

版權聲明：原創作品，謝絕轉載！否則將追究法律責任。

 

 

 

一.函數式編程初體驗Spark-Shell之WordCount

var arr=Array("hello","yinzhengjie","hello","world","yinzhengjie","big","data")            //聲明一個數組

arr.map((_,1)).groupBy(_._1).mapValues(_.length).toList.sortBy(-_._2)            　　　　　　//使用Spark進行單詞個數統計並進行降序

　　使用CMD窗口操作如下：

 

 

二.變量定義以及條件表達式

1>.數據類型介紹

　　答：Scala 和Java 相似，有7 種數值類型Byte、Char、Short、Int、Long、Float 和Double（無包裝類型）和Boolean、Unit 類型.注意:Unit 表示無值，和其他語言中void 等同。用作不返回任何結果的方法的結果類型。Unit只有一個實例值，寫成()。下圖展示了Scala中的整體類層級圖，其中Any位於最頂端，Nothing位於最底端。 

2>.變量定義

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.basicGrammar

object DefiningVariable {
    def main(args: Array[String]): Unit = {
        /**
          * 變量的定義可以用關鍵字var和val修飾
          *     var修飾的變量值可以更改
          *     val修飾的變量值不可用改變，相當於Java中final修飾的變量
          *     定義變量格式如下 :
          *         方式一 : var | val 變量名稱 : 類型 = 值
          *         方式二 : var | val 變量名稱 = 值
          *
          */
        val name:String = "尹正傑"
        var age:Int = 26
        val blog = "http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/"
        // 輸出我們上面定義的變量
        println ("姓名 :" + name , "年齡 :" + age , "博客地址 :" + blog )

        /**
          * Unit數據類型相當於Java中void關鍵字，但是在scala它的表示形式是一對括號，即"()"。
          *     由於我println返回值為空，因此我定義了一個變量res它拿到的返回值必然為空。
          */
        val res:Unit=println("yinzhengjie")
        println(res)
        /**
          * 文字'f'插值器允許創建一個格式化的字符串，類似於C語言中的printf。注意，如果你沒有寫文字'f'插值器的話，格式化字符串會原樣輸出喲
          * 在使用'f'插值器時，所有變量引用都應該是printf 樣式格式說明符，如％d，％i，％f 等。
          */
        println (f"姓名 :$name%s 年齡 :$age, 博客地址 :$blog ") // 該行輸出有換行
        /**
          * 's'允許在處理字符串時直接使用變量。
          * 在println 語句中將String 變量($name)附加到普通字符串中。
          */
        println (s"Name=$name , Age=$age , Url=$blog ")
        /**
          * 字符串插入器還可以處理任意表達式。
          * 使用's'字符串插入器處理具有任意表達式"${10 * 10}"的字符串"10 x 10"的以下代碼片段。任何表達式都可以嵌入到${}中。
          */
        println (s"10 x 10 = ${10 * 10}")

        /**
          * 擴展小知識一:
          *     多個變量聲明模式
          */
        val (x,y,z) = (100,200,300)
        println(s"x = ${x},y = ${y},z = ${z}")

        /**
          * 擴展小知識二
          *     抽取前兩個元素依次賦值,目的只是關心a,b兩個值，這樣我們就可以直接輸出a和b的值
          */
        val Array(a,b,_*) = Array("A","B","C","D")
        println(s"a = ${a},b = ${b}")


    }
}



/*
以上代碼輸出結果如下 :
(姓名 :尹正傑,年齡 :26,博客地址 :http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/)
yinzhengjie
()
姓名 :尹正傑 年齡 :26, 博客地址 :http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 
Name=尹正傑 , Age=26 , Url=http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 
10 x 10 = 100
x = 100,y = 200,z = 300
a = A,b = B
 */

3>.條件表達式

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.variable

object ConditionalExpression {
    def main(args: Array[String]): Unit = {
        /**
          * if 語句的使用
          */
        val Name = "尹正傑"
        if (Name == "尹正傑"){
            println("歡迎使用Scala！")
        }
        /**
          * if...else 語句的使用
          */
        val sex = "boy"
        val  res = if (sex == "boy") "小哥哥" else "小姐姐"     //這個和Python中的三元表達式很像喲！
        println(res)

        /**
          * if...else if ...else多分支語句
          */
        val age:Int = 18
        var Title = if (age > 38){      //注意:我們在定義Title變量是並沒有指定數據類型，編譯器會自動推測出返回值類型，如果上面都沒有返回默認就是Unit喲！
            "大叔"
        }else if (age > 20){
            "小哥哥"
        }else{
            "小鮮肉"
        }
        println(s"${Title}")
    }
}



/*
以上代碼輸出結果如下 :
歡迎使用Scala！
小哥哥
小鮮肉
 */

 

三.循環語句for及yield關鍵字

1>.遍歷數組的幾種方式

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.variable

object CircularStatement {
    def main(args: Array[String]): Unit = {
        //定義一個數組
        val arr = Array(1,2,3,4,5)
        //遍歷數組的中的所有元素
        for (item <- arr){
            print(item + " ")
        }
        println("\n=======我是分割線==========")
        //定義一個數組，用面的每一個元素代表arr數組中的角標，從而達到訪問arr每一個元素的目的
        val  index = Array[Int](0,1,2,3,4)
        for (item <- index){
            print(arr(item) + "|")
        }
        println("\n=======我是分割線==========")
        //以角標的方式會訪問，注意“0 to 4”,會生成一個“(0,1,2,3,4)”的數組
        for (item <- 0 to  4){
            print(arr(item) + " ")
        }
        println("\n=======我是分割線==========")
        //以角標的方式會訪問，注意“0 until arr.length”,也會生成一個“(0,1,2,3,4)”的數組,因為arr.length的值為5
        for (item <- 0 until arr.length){
            print(arr(item) + "|")
        }
        println("\n=======我是分割線==========")
        //取出數組中的偶數元素
        for (item <- arr){
            if (item % 2 == 0){
                print(item + " ")
            }
        }
        println("\n=======我是分割線==========")
        //當然，上面的循環表達式也可以簡寫，如下：
        for (item <- arr if item % 2 == 0){
            print(item + " ")
        }
    }
}





/*
以上代碼執行結果如下 :
1 2 3 4 5 
=======我是分割線==========
1|2|3|4|5|
=======我是分割線==========
1 2 3 4 5 
=======我是分割線==========
1|2|3|4|5|
=======我是分割線==========
2 4 
=======我是分割線==========
2 4 
 */

2>.循環的嵌套方式

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.variable

object CircularStatement {
    def main(args: Array[String]): Unit = {
        for (i <-1 to 3){
            for (j <- 1 to 3){
                if (i != j){
                    print(10 * i + j + " ")
                }
            }
        }
        println("\n=======我是分割線==========")
        //上面的for循環嵌套是很繁瑣的，我們可以用一行搞定！
        for(i <- 1 to 3;j <-1 to 3 if i != j){
            print(10 * i + j + " ")
        }
    }
}





/*
以上代碼執行結果如下 :
12 13 21 23 31 32
=======我是分割線==========
12 13 21 23 31 32 
 */

3>.yield關鍵字

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.variable

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

        val arr = Array(1,2,3,4,5)

        //yield關鍵字和Python很類似，它可以多次返回值，比如我們判斷arr數組中存在的偶數值
        var res = for(item <- arr if item % 2 == 0) yield item

        //遍歷我們得到的數組
        for(item <- 0 until res.length){
            print(res(item) + " ")
        }

    }
}





/*
以上代碼執行結果如下 :
2 4 
 */

 4>.小試牛刀-打印九九乘法表

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.basicGrammar

object MultiplicationTable {
    def main(args: Array[String]): Unit = {
        for_while_99(9)
        println("=======我是分割線==========")
        while_while_99(10)
        println("=======我是分割線==========")
        for_for_99(9)
        println("=======我是分割線==========")
        senior_for(9)
    }

    /**
      * 使用高級for循環打印99乘法表，當然是在傳遞的參數為9的情況下
      */
    def senior_for(arg:Int):Unit={
        for(i<-1 to arg;j<-1 to i ){
            print(s"${i} x ${j} = ${i * j}\t")
            if (j == i) {
                println()
            }
        }
    }

    /**
      * 使用for循環嵌套打印99乘法表,我們需要傳入一個參數，可以實現任意乘法表
      */
    def for_for_99(arg:Int):Unit={
        for(i <- 1 to arg){
            for (j <- 1 to i){
                print(s"${i} x ${j} = ${i * j}\t")
                if (j == i) {
                    println()
                }
            }
        }
    }
    /**
      * 使用while循環嵌套打印99乘法表，我們需要傳入一個參數，可以實現任意乘法表
      */
    def while_while_99(arg:Int): Unit ={
        var i = 1
        while (i < arg){
            var j = 1
            while (j <= i){
                printf("%d x %d = %d\t",j,i,(j*i))
                if (j == i){
                    println()
                }
                j+=1
            }
            i+=1
        }
    }
    /**
      * 使用while和for循環打印99乘法表，我們需要傳入一個參數，可以實現任意乘法表
      */
    def for_while_99(arg:Int):Unit = {
        var i: Int = 1
        for (i <- 1 to arg) {
            var j = 1
            while (j <= i) {
                print(s"${i} x ${j} = ${i * j}\t")
                if (j == i) {
                    println()
                }
                j += 1
            }
        }
    }
}


/*
以上代碼執行結果如下 :
1 x 1 = 1
2 x 1 = 2    2 x 2 = 4
3 x 1 = 3    3 x 2 = 6    3 x 3 = 9
4 x 1 = 4    4 x 2 = 8    4 x 3 = 12    4 x 4 = 16
5 x 1 = 5    5 x 2 = 10    5 x 3 = 15    5 x 4 = 20    5 x 5 = 25
6 x 1 = 6    6 x 2 = 12    6 x 3 = 18    6 x 4 = 24    6 x 5 = 30    6 x 6 = 36
7 x 1 = 7    7 x 2 = 14    7 x 3 = 21    7 x 4 = 28    7 x 5 = 35    7 x 6 = 42    7 x 7 = 49
8 x 1 = 8    8 x 2 = 16    8 x 3 = 24    8 x 4 = 32    8 x 5 = 40    8 x 6 = 48    8 x 7 = 56    8 x 8 = 64
9 x 1 = 9    9 x 2 = 18    9 x 3 = 27    9 x 4 = 36    9 x 5 = 45    9 x 6 = 54    9 x 7 = 63    9 x 8 = 72    9 x 9 = 81
=======我是分割線==========
1 x 1 = 1
1 x 2 = 2    2 x 2 = 4
1 x 3 = 3    2 x 3 = 6    3 x 3 = 9
1 x 4 = 4    2 x 4 = 8    3 x 4 = 12    4 x 4 = 16
1 x 5 = 5    2 x 5 = 10    3 x 5 = 15    4 x 5 = 20    5 x 5 = 25
1 x 6 = 6    2 x 6 = 12    3 x 6 = 18    4 x 6 = 24    5 x 6 = 30    6 x 6 = 36
1 x 7 = 7    2 x 7 = 14    3 x 7 = 21    4 x 7 = 28    5 x 7 = 35    6 x 7 = 42    7 x 7 = 49
1 x 8 = 8    2 x 8 = 16    3 x 8 = 24    4 x 8 = 32    5 x 8 = 40    6 x 8 = 48    7 x 8 = 56    8 x 8 = 64
1 x 9 = 9    2 x 9 = 18    3 x 9 = 27    4 x 9 = 36    5 x 9 = 45    6 x 9 = 54    7 x 9 = 63    8 x 9 = 72    9 x 9 = 81
=======我是分割線==========
1 x 1 = 1
2 x 1 = 2    2 x 2 = 4
3 x 1 = 3    3 x 2 = 6    3 x 3 = 9
4 x 1 = 4    4 x 2 = 8    4 x 3 = 12    4 x 4 = 16
5 x 1 = 5    5 x 2 = 10    5 x 3 = 15    5 x 4 = 20    5 x 5 = 25
6 x 1 = 6    6 x 2 = 12    6 x 3 = 18    6 x 4 = 24    6 x 5 = 30    6 x 6 = 36
7 x 1 = 7    7 x 2 = 14    7 x 3 = 21    7 x 4 = 28    7 x 5 = 35    7 x 6 = 42    7 x 7 = 49
8 x 1 = 8    8 x 2 = 16    8 x 3 = 24    8 x 4 = 32    8 x 5 = 40    8 x 6 = 48    8 x 7 = 56    8 x 8 = 64
9 x 1 = 9    9 x 2 = 18    9 x 3 = 27    9 x 4 = 36    9 x 5 = 45    9 x 6 = 54    9 x 7 = 63    9 x 8 = 72    9 x 9 = 81
=======我是分割線==========
1 x 1 = 1
2 x 1 = 2    2 x 2 = 4
3 x 1 = 3    3 x 2 = 6    3 x 3 = 9
4 x 1 = 4    4 x 2 = 8    4 x 3 = 12    4 x 4 = 16
5 x 1 = 5    5 x 2 = 10    5 x 3 = 15    5 x 4 = 20    5 x 5 = 25
6 x 1 = 6    6 x 2 = 12    6 x 3 = 18    6 x 4 = 24    6 x 5 = 30    6 x 6 = 36
7 x 1 = 7    7 x 2 = 14    7 x 3 = 21    7 x 4 = 28    7 x 5 = 35    7 x 6 = 42    7 x 7 = 49
8 x 1 = 8    8 x 2 = 16    8 x 3 = 24    8 x 4 = 32    8 x 5 = 40    8 x 6 = 48    8 x 7 = 56    8 x 8 = 64
9 x 1 = 9    9 x 2 = 18    9 x 3 = 27    9 x 4 = 36    9 x 5 = 45    9 x 6 = 54    9 x 7 = 63    9 x 8 = 72    9 x 9 = 81
 */

 

四.運算符重載成方法

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.variable

object OperatorReloadingMethod {
    def main(args: Array[String]): Unit = {
        var res1 = 1 + 2
        println(res1)
        //上面的運算符“+”其實是運算符重載成方法，即".+"
        var res2 = 1.+(2)
        println(res2)

        val res3 = 1 to 10
        println(res3)
        //上面的運算符“to”其實也是運算符重載成方法，即".to"
        val  res4 = 1.to(10)
        println(res4)

    }
}

/*
以上代碼輸出結果如下 :
3
3
Range 1 to 10
Range 1 to 10
 */

 

五.Scala中定義方法和函數簡介

1>.有參函數和無參函數以及方法轉換成函數案例

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.function

object Method {

    /**
      * 定義有參函數 :
      *     定義個 sum 方法(用關鍵字def來標識方法), 該方法有 3 個參數(即a,b和c), 參數類型為整型, 方法的返回值為整型，
      */
    def sum(a:Int, b: Int,c:Int): Int = {
        //方法體是將形參列表的三個參數進行相加操作，相加的結果就是返回值的整形
        a + b + c
    }

    /**
      * 定義無參函數 :
      *     改方法沒有任何參數, 也沒有返回值。注意：如果方法沒有括號"()" 調用時不能加"()"
      */
    def sayHello() ={
        println("I'm Yinzhengjie！")
    }

    def main(args: Array[String]): Unit = {
        //調用有參函數
        var res = sum(100,200,300)
        println(res)

        //調用無參函數,調用時可以省略括號"()", 也可以不省略。如果方法沒有括號"()"，調用時不能加"()"
        sayHello()

        //方法可轉換為函數，格式很簡單，只需要在方法名后面加個空格和下划線即可。
        var f1 = sum _
        //調用我們將方法轉換過來的函數
        var res1 = f1(1,2,3)
        println(res1)
    }
}

/**
  * 以上代碼執行結果如下 :
  * 600
  * I'm Yinzhengjie！
  * 6
  */

2>.匿名函數的兩種定義和調用方式

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.function

object Method {

    /**
      * 函數定義方式一:
      * f1 :
      *     其中f1是對匿名函數簽名的一個引用，我們可以通過f1去調用這個函數，
      * (x : Int) :
      *     其中x是變量的名稱，而Int是變量的類型
      *  => :
      *     表示的是函數標志
      * x * 2 ：
      *     表示的具體的函數體，即也是最終的返回值喲
      */
    val  f1 = (x:Int) => x * 2


    /**
      * 函數定義方式而:
      * f2 :
      *     其中f2是對匿名函數簽名的一個引用，我們可以通過f2去調用這個函數，
      * (Int) :
      *     Int定義的是函數的參數類型，我這個定義了一個Int類型的參數，如果有多個用逗號分隔即可
      *  => :
      *     表示的是函數標志
      * Int ：
      *     表示的是返回值類型為Int
      * (x) :
      *     注意，這里的x實際上是形參，這個參數的類型就是前面我們定義的Int類型
      * x * 2 ：
      *     表示的具體的函數體，即也是最終的返回值喲
      */
    val f2 :(Int) => Int =(x) => x * 2

    /**
      * 下面為沒有任何參數的匿名函數, 函數的返回值為String類型.
      *
      */
    val f3:() => String = () => "尹正傑"

    def main(args: Array[String]): Unit = {
        //調用匿名函數f1
        var res1 = f1(10)
        println(res1)

        //調用匿名函數f2
        var res2 = f1(20)
        println(res2)

        //調用參數為空的匿名函數f3
        val  Name = f3();
        println(Name)

    }
}

/**
  * 以上代碼執行結果如下 :
  * 20
  * 40
  * 尹正傑
  */

　　想要了解更多關於函數知識點筆記請參考：https://www.cnblogs.com/yinzhengjie/p/9352798.html。