Scala运算符及流程控制

---

---

写在前面

• 操作系统：Windows10
• JDK版本：jdk1.8
• Maven版本：Maven-3.5.4
• Scala版本：Scala-2.12.11
• IDE工具：IntelliJ IDEA 2019.2.3

scala运算符的使用和Java运算符的使用基本相同，只有个别细节上不同。

运算符

算数运算符

我们先定义变量 A 为 10，B 为 20，那么+、-、*、/四个算术运算符的结果如下图所示：

关系运算符

我们先定义变量 A 为 10，B 为 20，那么==、!=、>、<、>=、<=六个关系运算符的结果如下图所示：

赋值运算符

已知有变量 A，B，C，那么==、+=、-=、*=、/=、%=、<<=、&=、^=、^|=一共11个赋值运算符的结果如下图所示：

逻辑运算符

我们先定义变量 A 为 1，B 为 0，那么&&、||、!三个运算符的结果如下图所示：

位运算符

我们先定义变量 A = 60; 及 B = 13; 同时两个变量对应的二进制为：

A = 0011 1100
B = 0000 1101

那么，各种使用位运算符号最终的运算结果如下图所示：

运算符本质

在Scala中其实是没有运算符的，所有运算符都是**方法**。

• scala是完全面向对象的语言，所以数字其实也是对象

• 当调用对象的方法时，点.可以省略

• 如果函数参数只有一个，或者没有参数，()可以省略

举例如下所示：.+()表示方法

object ScalaOper {
    def main(args: Array[String]): Unit = {
        val i : Int = 10
        val j : Int = i.+(10)
        val k : Int = j +(20)
        val m : Int = k + 30
        println(m)
    }
}

流程控制

Scala程序代码和所有编程语言代码一样，都会有特定的执行流程顺序，默认情况下是顺序执行，上一条逻辑执行完成后才会执行下一条逻辑，执行期间也可以根据某些条件执行不同的分支逻辑代码。

分支控制

让程序有选择的的执行，分支控制有三种：单分支、双分支、多分支

单分支

IF…ELSE 语句是通过一条或多条语句的执行结果（true或者false）来决定执行的代码块

if(布尔表达式) {
  // 如果布尔表达式为 true 则执行该语句块
}

如果布尔表达式为 true 则执行大括号内的语句块，否则跳过大括号内的语句块，执行大括号之后的语句块。

object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val b = true
        if (b) {
           println("true")
  		  }
    }
}

双分支

if(布尔表达式) {
  // 如果布尔表达式为 true 则执行该语句块
} else {
  // 如果布尔表达式为 false 则执行该语句块
}

如果布尔表达式为 true 则执行接着的大括号内的语句块，否则执行else后的大括号内的语句块。

object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val b = true
        if (b) {
            println("true")
    } else {
        println("false")
    }
    }
}

多分支

if(布尔表达式1) {
  // 如果布尔表达式1为 true，则执行该语句块
} else if ( 布尔表达式2 ) {
  // 如果布尔表达式2为 true，则执行该语句块
}...
} else {
  // 上面条件都不满足的场合，则执行该语句块
}

实现一个小功能：输入年龄，如果年龄小于18岁，则输出“童年”。如果年龄大于等于18且小于等于30，则输出“青年”，如果年龄大于30小于等于50，则输出”中年”，否则，输出“老年”。

object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val age = 30
        if ( age < 18 ) {
            println("童年")
        } else if ( age <= 30 ) {
            println("青年")
        } else if ( age <= 50 ) {
            println("中年")
        } else {
            println("老年")
        }
    }
}

实际上，Scala中的表达式都是有返回值的，所以上面的小功能还有其他的实现方式

object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val age = 30
        val result = if ( age < 18 ) {
            "童年"
        } else if ( age <= 30 ) {
            "青年"
        } else if ( age <= 50 ) {
            "中年"
        } else {
            "老年"
        }
        println(result)
   }
}

循环控制

有的时候，我们可能需要多次执行同一块代码。一般情况下，语句是按顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。编程语言提供了更为复杂执行路径的多种控制结构。循环语句允许我们多次执行一个语句或语句组

Scala语言提供了以下几种循环类型

for循环

• 基本语法

for (循环变量 <- 数据集) {
  循环体
}

这里的数据集可以是任意类型的数据集合，如字符串，集合，数组等，这里我们还没有讲到集合，数组语法，请大家不要着急，先能演示例子，后面咱们详细讲。

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

• 循环守卫

循环时可以增加条件来决定是否继续循环体的执行,这里的判断条件我们称之为循环守卫

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for (i <- Range(1,7) if i != 4) {
            println("i = " + i)
        }
    }
}

• 循环步长

Scala的集合也可以设定循环的增长幅度，也就是所谓的步长step

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for (i <- Range(1,7,2)) {
            println("i = " + i)
        }
        for (i <- 1 to 7 by 2) {
            println("i = " + i)
        }
    }
}

• 循环嵌套

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for (i <- Range(1,7); j <- Range(1,6)) {
            println("i = " + i + ",j = " + j)
        }
        for ( i <- Range(1,7) ) {
            for ( j <- Range(1,6)) {
                println("i = " + i + ",j = " + j)
            }
        }
    }
}

Note：请好好体会上面两种嵌套方式的区别。

• 引入变量

引入j变量

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for (i <- Range(1,7); j = i - 1) {
            println("j = " + j )
        }
    }
}

• 循环返回值

Scala所有的表达式都是有返回值的。但是这里的返回值并不一定都是有值的哟。

如果希望for循环表达式的返回值有具体的值，需要使用关键字yield

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        val result = for (i <- Range(1,7) ) yield {
            i * 2
        }
        println(result)
    }
}

while循环

• 基本语法**

当循环条件表达式返回值为true时，执行循环体代码

while( 循环条件表达式 ) {
  循环体
}

一种特殊的while循环就是，先执行循环体，再判断循环条件是否成立

do {
  循环体
} while ( 循环条件表达式 )

• while循环

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        var i = 0
        while (i < 7) {
            println(i)
            i += 1
        }
    }
}

• do...while循环

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        var i = 7
        do {
            println(i)
        } while (i < 7)
    }
}

循环中断

scala是完全面向对象的语言，所以无法使用break，continue关键字这样的方式来中断，或继续循环逻辑，而是采用了函数式编程的方式代替了循环语法中的break和continue（scala.util.control.Breaks.break）

object ScalaLoop {
  def main(args: Array[String]): Unit = {
    scala.util.control.Breaks.breakable {
      for (i <- 1 to 5) {
        if (i == 3) {
          scala.util.control.Breaks.break
        }
        println(i)
      }
    }
  }
}

嵌套循环

循环中有循环，就是嵌套循环。

全文结束！