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:y1053419035@qq.com
*/
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:y1053419035@qq.com
*/
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:y1053419035@qq.com
*/
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("
=======我是分割线==========")
        //定义一个数组，用面的每一个元素代表arr数组中的角标，从而达到访问arr每一个元素的目的
        val  index = Array[Int](0,1,2,3,4)
        for (item <- index){
            print(arr(item) + "|")
        }
        println("
=======我是分割线==========")
        //以角标的方式会访问，注意“0 to 4”,会生成一个“(0,1,2,3,4)”的数组
        for (item <- 0 to  4){
            print(arr(item) + " ")
        }
        println("
=======我是分割线==========")
        //以角标的方式会访问，注意“0 until arr.length”,也会生成一个“(0,1,2,3,4)”的数组,因为arr.length的值为5
        for (item <- 0 until arr.length){
            print(arr(item) + "|")
        }
        println("
=======我是分割线==========")
        //取出数组中的偶数元素
        for (item <- arr){
            if (item % 2 == 0){
                print(item + " ")
            }
        }
        println("
=======我是分割线==========")
        //当然，上面的循环表达式也可以简写，如下：
        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:y1053419035@qq.com
*/
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("
=======我是分割线==========")
        //上面的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:y1053419035@qq.com
*/
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:y1053419035@qq.com
*/
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}	")
            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}	")
                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	",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}	")
                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:y1053419035@qq.com
*/
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:y1053419035@qq.com
*/
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:y1053419035@qq.com
*/
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。