大数据课程J2——Scala的基础语法和函数

文章作者邮箱：[e-mail]              地址：广东惠州

 ▲ 本章节目的

⚪ 掌握Scala的基础语法；

⚪ 掌握Scala的函数库；

一、Scala 基础语法一

1. 概述

语句	说明	示例
var	用来声明一个变量， 变量声明后，在程序执行过程中可以被修改。	def main(args: Array[String]): Unit = {     var var1=100     var var2:Int=100    //变量修改     var2=200;     var3="world";
val	用来声明一个常量， 一旦被赋值就不能再进行修改	//定义常量，但不允许修改常量 val vall = 100; //常量修改将报错 vall = 200;
操作符	scala中操作符即方法，方法即操作符 所以 可以认为 scala中并没有传统意义上的操作符 所有的操作符都是方法 所有的方法也都可以像操作符一样去使用	1. 算术运算符 + - * / % 2. 关系运算符 ==  !=  >   <   >=  <=== > < >= <= 3. 逻辑运算符 &&  ||  ! 4. 位运算符 ~  &  |  ^  <<   >>   >>> 5. 赋值运算符 =  +=  -=   *=   /=   %=

2. 算术运算符

下表列出了Scala支持的算术运算符。

假定变量A为10，B为20：

运算符	描述	实例
+	加号	A + B 运算结果为 30
-	减号	A - B 运算结果为 -10
*	乘号	A * B 运算结果为 200
/	除号	A / B 运算结果为 2
%	取余	A % B 运算结果为 0

3. 关系运算符

下表列出了Scala支持的关系运算符。

假定变量A为10，B为20：

运算符	描述	实例
==	等于	( A == B ) 运算结果为 false
!=	不等于	( A != B ) 运算结果为 true
>	大于	( A > B ) 运算结果为 false
<	小于	( A < B ) 运算结果为 true
>=	大于等于	( A >= B ) 运算结果为 false
<=	小于等于	( A <= B ) 运算结果为 true

4. 逻辑运算符

下表列出了Scala支持的关系运算符。

假定变量A为1，B为0：

运算符	描述	实例
&&	逻辑与	( A && B ) 运算结果为 false
||	逻辑或	( A || B ) 运算结果为 true
!	逻辑非	! ( A && B ) 运算结果为 true

5. 位运算符

位运算符用来对二进制位进行操作，~,&,|,^ 分别为取反，按位与与，按位与或，按位与异或运算，如下实例：

运算符	描述	实例
&	按位与运算符	(a & b) 输出结果12，二进制解释：0000  1100
|	按位或运算符	(a | b) 输出结果61，二进制解释：0011  1101
^	按位异或运算符	(a ^ b) 输出结果49，二进制解释：0011  0001
~	按位取反运算符	(~a) 输出结果-61，二进制解释：1100  0011, 在一个有符号二进制数的补码形式。
<<	左移动运算符	a<<2 输出结果240，二进制解释：1111  0000
>>	右移动运算符	a>>2 输出结果15，二进制解释：0000  1111
>>>	无符号右移	a>>>2 输出结果15，二进制解释：0000  1111

6. 赋值运算符

一下列出了Scala语言支持的赋值运算符：

运算符	描述	实例
=	简单的赋值运算，指定右边的操作数赋值给左边的操作数。	C = A + B 将 A + B 的运算结果赋值给 C
+=	相加后再赋值，将左右两边的操作数相加后再赋值给左边的操作数。	C += A 相当于 C = C + A
-=	相减后再赋值，将左右两边的操作数相减后再赋值给左边的操作数。	C -= A 相当于 C = C - A
*=	相乘后再赋值，将左右两边的操作数相乘后再赋值给左边的操作数。	C *= A 相当于 C = C * A
/=	相除后再赋值，将左右两边的操作数相除后再赋值给左边的操作数。	C /= A 相当于 C = C / A
%=	求余后再赋值，将左右两边的操作数求余后再赋值给左边的操作数。	C %= A 相当于 C = C % A

二、Scala 基础语法二

语句	说明	示例
if……else	if……else 判断 if是具有返回值的，if判断后，将执行代码的最后一个表达式的值返回作为整个if执行后的结果。	//一个简单的示例     var var1=10;     if(var1<100){       println("小了")     }else{       println("大了")     }         //根据scala函数式编程风格，建议做如下更改     //尽量使用常量     val val1=10;     //if……else最后一行的值是返回值，可省略return     val result=          if(val1<100){            "小了";          }else{            "大了";          }     print(result)     //也可以简化成下面的形式     val val2=10;     println(if(val2<100)"小了"else"大了");
while	和java中用法相同	//一个简单的例子     val val1=List(1,2,3,4);     var index=0;     while(index<val1.size){       println(val1(index));       index+=1;     }
for	scala中的for要比java的for强大，使用很频繁，需要熟练掌握。	//生成一个1~100的区间，区间类型是range     val val1=1 to 100;         //循环遍历并打印     for(num <-val1){       println(num)     }         //支持条件过滤     for(num<-val1;if num>50){       println(num)     }         //支持多条件过滤     for(num<-val1;if num>50;if num%2==0;if num<90)       println(num)    //也可以写成下面的形式     for(num<- 1 to 100;if num>50&&num<90&&num%2==0){       println(num)     }
try catch finally	scala中继承了java的异常机制	import java.lang try {       throw new RuntimeException("error");     }catch {        case t: NullPointerException => t.printStackTrace();("空指针异常");       case t: Exception=>t.printStackTrace();println("其他异常");     }finally {       println("资源释放")     }
match	scala中的match类似于其他语言的switch	//一个简单的例子 //match匹配到case后，执行case对应的内容，然后退出match,于java不同的是，不需要写break     val val1="bbb";     val1 match {       case "aaa" =>println("1");       case "bbb" =>println("2");       case  _ =>println("3");     }         //此外，match可以带有返回值     val result=val1 match{       case "aaa" =>1       case "bbb" =>2       case  _ =>3     }
break continue	scala中没有break和continue语句，需要通过另外的形式来实现	import util.control.Breaks._ object Demo12 {   def main(args: Array[String]): Unit = {           //实现break      breakable(    for(i <- 1 to 10){        if(i==8){           break();        }else{          println(i);        }      }          )           //实现continue      for(i<-1 to 10){        breakable(         if(i==8){           break;         }else{           println(i);         }        )      }             } }

三、Scala函数上篇

1. 函数声明

scala 函数通过 def 关键字定义，def前面可以具有修饰符，可以通过private、protected来控制其访问权限。

注意：没有public，不写默认就是public的。 此外也可跟上override，final等关键字修饰。

2. 函数返回值

1. 函数体中return关键字往往可以省略掉，一旦省略掉，函数将会返回整个函数体中最后一行表达式的值，这也要求整个函数体的最后一行必须是正确类型的值的表达式。

2. 大部分时候scala都可以通过 =符号 来自动推断出返回值的类型，所以通常返回值类型声明可以省略。

但是注意：如果因为省略了返回值类型造成歧义，则一定要写上返回值声明。

3. 如果函数体只有一行内容，则包裹函数体的大括号可以省略

4. 如果返回值类型是UNIT,则另一种写法是可以去掉返回值类型和等号，把方法体写在花括号内,而这时方法内无论返回什么，返回值都是 UNIT。                

格式：[private/protected] def 函数名(参数列表):返回值声明 = {函数体}

示例：

  //方法的返回值为空

  def f1():Unit={

     println("hello scala");

  }

  //等价于f1()方法，注意：如果函数没有=号，无论函数体里的返回值是什么，函数的返回值都是Unit

  def f2(){

    println("hello scala");

  }

  //定义方法参数类型，返回值类型，及返回值

  def f3(a:Int,b:Int):Int={

    a+b;

  }

  //scala可自行推断返回值类型，所以可省略返回值类型

  def f4(a:Int,b:Int)={

    a+b;

  }

  //如果函数体只一行内容，可以省了花括号

  def f5(a:Int,b:Int)=a+b

  //注意下面这种形式，因为没有=号，所以函数的返回值是Unit,即（）

  def f6(a:Int,b:Int){

    a+b

  }

3. 默认参数

代码示意：

object Demo21 {

  def f1(a:String,b:String="[",c:String="]")={

    b+a+c

  }

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

    print(f1("hello"))//将打印:[hello]

  }

}

4. 函数的种类

1.成员函数

2.本地函数(内嵌在函数内的函数)

3.函数值(匿名函数)

4.高阶函数

成员函数： 函数被使用在类的内部，作为类的一份子，称为类的成员函数

示例：

object Demo15 {

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

    val p=new Student();

    p.eat();

    p.study();

  }

  // eat() 和study()属于 类Student的成员函数

  class Student{

    def eat(){

      println("吃饭")

    }

    def study(){

      println("学习")

    }

  }

}

本地函数：函数内嵌的函数称为本地函数，这样的函数外界无法访问

示例：

object Demo16 {

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

    val p=new Student();

    p.eat("肉");

  }

  class Student{

    def eat(food:String){

      //cook函数内嵌在eat函数里，这样的函数称之为本地函数

      def cook(food:String):String={

        "做熟了的"+food;

      }

      println("吃"+cook(food));

    }

  }

}

函数值 - 匿名函数：

示例：

    def f1(a:Int,b:Int):Int={a+b};

    //等价于上式的函数

    (a:Int,b:Int)=>{a+b};

    //如果函数体只有一行代码，可以省去大括号

    (a:Int,b:Int)=>a+b;

    //如果函数参数列表只有一个参数，小括号有可以省略

    a:Int=>a+1;

    //如果函数的参数类型可以被推测，则可以省略类型值

    //(a,b)=>a+b

    def f1(a:Int,b:Int):Int={a+b};

    //可以将f1()函数赋值给f2常量

    val f2=f1(_,_);

    //可以将f1()函数赋值给f3变量，f3可以更改此函数

    var f3=f1(_,_);

    f3=(a:Int,b:Int)=>a*b;

    //也可以这样写

    val f4=(c:Int,d:Int)=>{c+d}

    //注意，下面的写法是将f1的函数值复制给f5，而不是函数赋值给f5

    val f5=f1(2,3)

四、Scala函数下篇

1. 高阶函数：

高阶函数（Higher-Order Function）就是操作其他函数的函数。

Scala 中允许使用高阶函数, 高阶函数可以使用其他函数作为参数，或者使用函数作为输出结果。

示例1：

object Demo01 {

  //定义了compute函数，a,b和f函数  三个参数。其中f函数未做实现。

  //我们的目的是对传入的a和b参数利用 f函数做运算，但是具体是什么运算需要由用户自己来指定。

  def compute(a:Int,b:Int,f:(Int,Int)=>Int):Int={

   f(a,b)

  }

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

    val f1=(a:Int,b:Int)=>{a+b}

    val f2=(a:Int,b:Int)=>{a*b}

    val f3=(a:Int,b:Int)=>{a-b}

    val f4=(a:Int,b:Int)=>{a/b}

    //由下式可以看出，scala中，函数可以当做参数进行传递和调用

    val result=compute(2,3,f1)

    //下式等价于上式

    //val result=compute(2,3,(a,b)=>{a+b})

  }

}

示例2：

object Demo02 {

  //定义了一个函数，作用是将用户处理后的字符串结果进行打印输出

  def handleString(a:String,f:(String)=>String){

    println("处理完后的字符串为:"+ f(a))

  }

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

    val a="hello scala";

    handleString(a,(a)=>{a});

    handleString(a,(a)=>{a.substring(6)});

    handleString(a,(a)=>{a.concat(" 1706")})

  }

}

占位符：占位符指的是scala中的下划线_ ，可以用它当作一个或多个参数来使用。

使用_占位符的前提要求：每个参数在函数仅出现一次。

使用下划线时，如果类型可以自动推断出，则不用声明类型。如果无法自动推断类型，则在下划线后自己来显示声明类型即可。

示例1：

object Demo03 {

  def compute(a:Int,b:Int,f:(Int,Int)=>Int):Int={

   f(a,b)

  }

  def handleString(a:String,f:(String)=>String){

    println("处理完后的字符串为:"+ f(a))

  }

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

    val message="hello scala";

    //这样用占位符会报错

    //handleString(message,(_)=>{_.substring(6)})

    //应改为下面的写法

    handleString(message,{_.substring(6)})

    //如果函数体只有一行代码，则还可以将大括号去掉

     handleString(message,_.substring(6))

    //compute的代码可简化如下 

    compute(2,3,_+_)

    compute(2,3,_*_)

    compute(2,3,_-_)

    //    此外

    //    val f1=(a:Int,b:Int)=>{a+b}

    //    等价于下式：

    //    val f1=(_:Int)+(_:Int)

    //    compute(2, 3, f1)

    //再来看一个例子

    val list=List(1,3,5,7,9)

    list.foreach { x =>print(x) }

    list.foreach { _ =>print(_) }

    list.foreach { print(_) }

    list.foreach { x => x*2 }

    list.foreach { _*2 }

  }

}

2. 递归函数

示例1：用递归方式实现斐波那契数列

 //0  1   1   2  3  5  8   13

 def f2(n:Int):Int={

if(n==0) return 0

if(n==1) return 1

else f2(n-1)+f2(n-2)

 }  

五、练习题

1.针对下列Java循环编写一个Scala版本:

for(int i=10;i>=0;i–)

     System.out.println(i);

2.编写一个函数countdown(n:Int)，打印从n到0的数字

3.编写函数计算x的n次方,其中n是整数，要考虑等n是0，正偶数，正奇数，负数这几种情况。

比如当x=2时，此函数要算出 2^4，2^3，2^0，2^(-1)对应的值

mi(x:Int，n：Int）：Double={    }

mi(2,10)=1024

mi(2,-1)=0.5

4.编写一个循环，将整数数组中相邻的元素置换

Array(1,2,3,4,5,6)

得到的结果：214365

5.创建一个Map，包含一些你想要的一些装备，以及他们的价格。然后通过yield 构建另一个Map映射，采用同一组键，但是价格上打9折

比如定义一个Map：

var m1=Map("book"->10,"gun"->100,"ipad"->1000) 

则输出的新map(m2）为：Map("book"->9,"gun"->90,"ipad"->900)