scala03-运算符和流程控制

运算符

算术运算符

    是对数值类型的变量进行运算的，在Scala程序中使用的非常多。

运算符

运算符	运算	举例
+	正好	a=1;  -a=-1
-	负号	a=-1;  -a=1
+	加	a=1+1;  a=2
-	减	a=2-1;  a=1
*	乘	a=2*2;  a=4;
/	除（结果取整数部分）	a=5/2;  a=2;
%	取模（结果去余数部分）	a=5%2;  a=1
+	字符串相加	a="ha"+"he";  a="hahe"

注意：

• 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。 例如：var x : Int = 10/3 ,结果是  3
• 当对一个数取模时，可以等价 a%b=a-a/b*b ， 这样我们可以看到取模的一个本质运算(和java 的取模规则一样)。
• 注意：Scala中没有++、--操作符，需要通过+=、-=来实现同样的效果

关系运算符(比较运算符)

关系运算符的结果都是boolean型，也就是要么是true，要么是false，注意一下细节：

• 使用陷阱: 如果两个浮点数进行比较，应当保证数据类型一致
• 关系运算符的结果都是Boolean型，也就是要么是true，要么是false。
• 关系运算符组成的表达式，我们称为关系表达式。 a > b

运算符	示例
==	1==2 , false
！=	1!=2, true
<	1<2, true
>	1>2, false
<=	1<=2, true
>=	1>=2, false

逻辑运算符

用于连接多个条件（一般来讲就是关系表达式），最终的结果也是一个Boolean值。

假设A为true，B为false

运算符	示例
&& 逻辑与	A&&B  false
||  逻辑或	A||B  true
！ 逻辑非	!(A&&B)  true

赋值运算符

赋值运算符就是将某个运算后的值，赋给指定的变量。特点：

1. 运算顺序从右往左
2. 赋值运算符的左边 只能是变量,右边 可以是变量、表达式、常量值/字面量
3. )复合赋值运算符等价于下面的效果      

分类

运算符	示例
=   赋值，将表达式值赋给左边变量	a = b+c
+=  相加后赋值	a+=b -> a=a+b
-=   相见后赋值	a-=b -> a=a-b
*=   相乘后赋值	a*=b -> a=a*b
/=    相除后赋值	a/=b -> a=a/b
%=   求余后赋值	a%=b -> a=a%b
<<=  左移后赋值	a<<=2 ->  a=a<<2
>>=  右移后赋值	a>>=2 ->  a=a>>2
&=  按位与后赋值	a&=2  -> a=a&2
^=  按位异或后赋值	a^=2 -> a=a^2
|=  按位或后赋值	a|=2 -> a=a|2

位运算符

分类

运算符	示例
& 与	(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

注意细节：

1 Scala不支持三目运算符 , 在Scala 中使用 if – else 的方式实现。

    val num = 5 > 4 ? 5 : 4  //没有 ，          val num = if (5>4) 5 else 4

2 只有整数才能位运算

3 运算顺序优先级

级别	运算符	关联性
1	() []	左到右
2	! ~	右到左
3	* / %	左到右
4	+ -	左到右
5	>> >>> <<	左到右
6	> >= < <=	左到右
7	== !=	左到右
8	&	左到右
9	^	左到右
10	|	左到右
11	&&	左到右
12	||	左到右
13	= += -= *= /= %= >>= <<= &= ^= |=	右到左
14	,	左到右

键盘输入语句

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。InputDemo.scala

方法：

  next 接受键盘输入的字符串

  nextInt 接受键盘输入的整数

  nextDouble接受键盘输入的浮点数

  nextBoolean接受键盘输入的buer

  next().charAt(0） 接收到一个字符

流程控制

Scala流程控制和Java流程控制类似，主要包含三大流程：1 顺序控住；2 分支控制；3 循环控制；

顺序控制

属于简单的流程控制，程序从上到下依次执行，中间不包含跳转；

分支控制

分支控制主要是 if-else 语句，主要包含三种形式：1 单分支；2 双分支；3 多分支；

单分支

if (条件表达式) ｛  
    执行代码块
｝
说明： 条件为真时，执行代码块内容

 双分支

if (条件表达式) {
	执行代码块1
} else {
	执行代码块2
}
说明：当条件表达式成立，即执行代码块1，否则执行代码块2.

多分支

if (条件表达式1) {
	执行代码块1
} else if (条件表达式2) {
	执行代码块2
} …… else {
	执行代码块n
}
说明：
1 依次从上到下判断条件，当某个条件符合时，执行条件下面代码块；
2 当某个条件符合时，下面同级别的条件不再判断；

注意：

1) 如果大括号{}内的逻辑代码只有一行，大括号可以省略, 这点和java 的规定一样。

2) Scala中任意表达式都是有返回值的，if else表达式有返回结果，具体返回结果的值取决于满足条件的代码体的最后一行内容，不同条件可以返回不同类型的结果。

object Test {
 def main(args: Array[String]): Unit = {
   var sumVal = 1
   val result = if(sumVal > 2){
      "结果大于2"   
   }
   println(result) //  } 
}

结果为：()

object Test {
 def main(args: Array[String]): Unit = {
   var sumVal = 3
   val result = if(sumVal > 2){
      "结果大于2"   
   }
   println(result) //  } 
}
结果为："结果大于2" 

3) Scala中是没有三元运算符，因为可以这样简写：val result = if (flg) 1 else 0  

switch

  scala中没有switch，类似的有模式匹配，具体看后面的章节。

循环分支

for分支

格式1：
for(i <- 1 to 3){
  print(i + " ")
}
println()
说明
i 表示循环的变量， <- 规定好 to 规定
i 将会从 1-3 循环， 前后闭合

格式2：
for(i <- 1 until 3) {
  print(i + " ")
}
println()
说明:
这种方式和前面的区别在于 i 是从1 到 3-1
前闭合后开的范围,和java的arr.length() 类似
for (int i = 0; i < arr.lenght; i++){}

格式3：
for(i <- 1 to 3 if i != 2) {
  print(i + " ")
}
println()
基本案例说明
循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue
上面的代码等价
for (i <- 1 to 3) {
	if (i != 2) {
		println(i+"")
	}
}

格式4：
for(i <- 1 to 3; j = 4 - i) {
  print(j + " ")
}
for(i <- 1 to 3; j = 4 - i) {
  print(j + " ")
}

循环返回值
基本案例
val res = for(i <- 1 to 10) yield i
println(res)
对基本案例说明
将遍历过程中处理的结果返回到一个新Vector集合中，使用yield关键字

使用花括号{}代替小括号()
基本案例
for(i <- 1 to 3; j =  i * 2) {
  println(" i= " + i + " j= " + j)
}
等价于
for{
      i <- 1 to 3
      j = i * 2} {
      println(" i= " + i + " j= " + j)
 }
说明
{}和()对于for表达式来说都可以
for 推导式有一个不成文的约定：
当for 推导式仅包含单一表达式时使用圆括号，当其包含多个表达式时使用大括号；
当使用{} 来换行写表达式时，分号就不用写了；

注意事项和细节说明
1 scala 的for循环形式和java是较大差异，这点请同学们注意，但是基本的原理还是一样的。
2 scala 的for循环的步长如何控制! [for(i <- Range(1,3,2)]
//如果要倒叙遍历 Range(3,1,-1)就可以了
//Range的范围和until 的规则一样
    println("for Range(开始,结束,频率) :")
    for(i <- Range(1,3,2)){
      println(i+" ")
    }

while循环

语法：
循环变量初始化
while (循环条件) {
    循环体(语句)
    循环变量迭代
}

注意事项和细节说明

 1)循环条件是返回一个布尔值的表达式

 2)while循环是先判断再执行语句

 3)与If语句不同，While语句本身没有值，即整个While语句的结果是Unit类型的()

 4)因为while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量 ，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环。

do..while循环控制

基本语法
  循环变量初始化;
   do{
      循环体(语句)
      循环变量迭代
   } while(循环条件)

注意事项和细节说明

1)循环条件是返回一个布尔值的表达式

2)do..while循环是先执行，再判断

3)和while 一样，因为do…while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量 ，而变量需要声明在do...while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环

多重循环控制

1)将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层】

2)实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

3)设外层循环次数为m次，内层为n次， 则内层循环体实际上需要执行m*n=mn次。

while循环的中断

Scala内置控制结构特地去掉了break和continue，是为了更好的适应函数化编程，推荐使用函数式的风格解决break和contine的功能，而不是一个关键字。

实现break：
  def main(args: Array[String]): Unit = {
    var n = 10
    breakable{  
      while(n <= 20){
        n += 1
        if(n == 18){
          break()        
        }      
      }    
    }
    println("n=" + n)  }
 }
如果将breakable() 更好理解，但是实际开发中，我们还是用breakable{} 方式

如何实现continue的效果：
Scala内置控制结构特地也去掉了continue，是为了更好的适应函数化编程，可以使用if – else 或是 循环守卫实现continue的效果
案例
for (i <- 1 to 10 if (i != 2 && i != 3)) {
println("i=" + i)
}

 

 

 

 

 

 

上一节：scala变量和数据类型                                                                                  下一节：函数和异常处理