记录今天学习记录：
流程控制
1 分支控制 if-else
让程序有选择的的执行，分支控制有三种：单分支、双分支、多分支
1.1 单分支
1）基本语法
if (条件表达式) {
执行代码块
}
说明：当条件表达式为 ture 时，就会执行{ }的代码。
2）案例
需求：输入人的年龄，如果该同志的年龄小于 18 岁，则输出“童年”
|
def main(args: Array[String]): Unit = {
println("请输入你的年龄:")
var age = StdIn.readShort()
if (age < 18){
println("童年")
}
}
|
运行
 |
1.2 双分支
1）基本语法
if (条件表达式) {
执行代码块 1
} else {
执行代码块 2
}
2）案例
需求：输入年龄，如果年龄小于 18 岁，则输出“童年”。否则，输出“成年”。
|
def main(args: Array[String]): Unit = {
println("请输入你的年龄:")
var age = StdIn.readShort()
if (age < 18){
println("童年")
}else{
println("成年")
}
}
|
 |
4.3 多分支
1）基本语法
if (条件表达式 1) {
执行代码块 1
}
else if (条件表达式 2) {
执行代码块 2
……
}else {
执行代码块 n
}
2）案例
（1）输入年龄，如果年龄小于 18 岁，则输出“童年”。如果年龄大于
等于 18 且小于等于 30，则输出“中年”，否则，输出“老年”。
|
def main(args: Array[String]): Unit = {
println("请输入你的年龄：")
var age = StdIn.readInt()
if (age < 18){
println("童年")
}else if(age>=18 && age<30){
println("中年")
}else{
println("老年")
}
}
|
 |
（2）Scala 中 if else 表达式其实是有返回值的，具体返回值取决于满足条件的
代码体的最后一行内容。
|
def main(args: Array[String]): Unit = {
println("请输入你的年龄:")
var age = StdIn.readInt()
val res :String = if (age < 18){
"童年"
}else if(age>=18 && age<30){
"中年"
}else{
"老年"
}
println(res)
}
|
对比：
|
def main(args: Array[String]): Unit = {
println("请输入你的年龄:")
var age = StdIn.readInt()
val res :String = if (age < 18){
"童年"
"你好"
}else if(age>=18 && age<30){
"中年"
}else{
"老年"
}
println(res)
}
|
第一个运行结果
 |
第二个运行结果：
 |
（3）Scala 中返回值类型不一致，取它们共同的祖先类型。
|
def main(args: Array[String]): Unit = {
println("请输入你的年龄")
var age = StdIn.readInt()
val res:Any = if (age < 18){
"童年"
}else if(age>=18 && age<30){
"中年"
}else{
100
}
println(res)
}
|
 |
（4）Java 中的三元运算符可以用 if else 实现
如果大括号{}内的逻辑代码只有一行，大括号可以省略。如果省略大括号，if 只对最近
的一行逻辑代码起作用。
|
def main(args: Array[String]): Unit = {
// Java
// int result = flag?1:0
// Scala
println("请输入你的年龄：")
var age = StdIn.readInt()
val res:Any = if (age < 18) "童年" else "成年"
"不起作用"
println(res)
}
|
 |
2 嵌套分支
在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层。
分支外面的分支结构称为外层分支。嵌套分支不要超过 3 层。
1）基本语法
if(){
if(){
}else{
}
}
2）案例
需求：如果输入的年龄小于 18，返回“童年”。如果输入的年龄大于等于 18，需要再判
断：如果年龄大于等于 18 且小于 30，返回“中年”；如果其他，返回“老年”。
|
def main(args: Array[String]): Unit = {
println("请输入你的年龄:")
var age = StdIn.readInt()
val res :String = if (age < 18){
"童年"
}else {
if(age>=18 && age<30){
"中年"
}else{
"老年"
}
}
println(res)
}
|
 |
3 For 循环控制
Scala 也为 for 循环这一常见的控制结构提供了非常多的特性，这些 for 循环的特性被称
为 for 推导式或 for 表达式。
3.1 范围数据循环（To）
1）基本语法
for(i <- 1 to 3){
print(i + " ")
}
println()
（1）i 表示循环的变量，<- 规定 to
（2）i 将会从 1-3 循环，前后闭合
例：
|
def main(args: Array[String]): Unit = {
for(i <- 1 to 5){
println(i)
}
}
|
 |
3.2 范围数据循环（Until）
1）基本语法
for(i <- 1 until 3) {
print(i + " ")
}
println()
（1）这种方式和前面的区别在于 i 是从 1 到 3-1
to可以取到3，而util取不到
（2）即使前闭合后开的范围
2）例
|
def main(args: Array[String]): Unit = {
for(i <- 1 until 5+1){
println(i)
}
}
|
 |
3.3 循环守卫（条件判断）
1）基本语法
|
for(i <- 1 to 3 if i != 2) {
print(i + " ")
}
println()
|
说明：
（1）循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为 true 则进入循环
体内部，为 false 则跳过，类似于 continue。
（2）上面的代码等价
|
for (i <- 1 to 3){
if (i != 2) {
print(i + " ")
}
}
|
2）例
输出 1 到 5 中，不等于 3 的值
|
def main(args: Array[String]): Unit = {
for (i <- 1 to 5 if i != 3) {
println(i)
}
}
|
 |
3.4 循环步长
1）基本语法
|
for (i <- 1 to 10 by 2) {
println("i=" + i)
}
|
说明：by 表示步长
2）例
输出 1 到 10 以内的所有奇数
|
def main(args: Array[String]): Unit = {
for (i <- 1 to 10 by 2) {
println("i=" + i)
}
}
|
输出结果
 |
3.5 嵌套循环
1）基本语法
|
for(i <- 1 to 3; j <- 1 to 3) {
println(" i =" + i + " j = " + j)
}
|
说明：没有关键字，所以范围后一定要加；来隔断逻辑
2）基本语法
上面的代码等价
|
for (i <- 1 to 3) {
for (j <- 1 to 3) {
println("i =" + i + " j=" + j)
}
}
|
3.6 引入变量
1）基本语法
|
for(i <- 1 to 3; j = 4 - i) {
println("i=" + i + " j=" + j)
}
|
说明：
（1）for 推导式一行中有多个表达式时，所以要加 ; 来隔断逻辑
（2）for 推导式有一个不成文的约定：当 for 推导式仅包含单一表达式时使用圆括号，
当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号，如下
|
for {
i <- 1 to 3
j = 4 - i
} {
println("i=" + i + " j=" + j)
}
|
2）例
上面的代码等价于
|
for (i <- 1 to 3) {
var j = 4 - i
println("i=" + i + " j=" + j)
}
|
3.7 循环返回值
1）基本语法
|
val res = for(i <- 1 to 10) yield i
println(res)
|
说明：将遍历过程中处理的结果返回到一个新 Vector 集合中，使用 yield 关键字。
注意：开发中很少使用。
2）例
将原数据中所有值乘以 2，并把数据返回到一个新的集合中。
|
def main(args: Array[String]): Unit = {
var res = for(i <-1 to 10) yield {
i * 2
}
println(res)
}
|
输出结果：
 |
3.8 倒序打印
1）说明：如果想倒序打印一组数据，可以用 reverse。
2）例：
倒序打印 10 到 1
|
def main(args: Array[String]): Unit = {
for(i <- 1 to 10 reverse){
println(i)
}
}
|
 |
4. While 和 do..While 循环控制
While 和 do..While 的使用和 Java 语言中用法相同。
4.1 While 循环控制
1）基本语法
循环变量初始化
while (循环条件) {
循环体(语句)
循环变量迭代
}
说明：
（1）循环条件是返回一个布尔值的表达式
（2）while 循环是先判断再执行语句
（3）与 for 语句不同，while 语句没有返回值，即整个 while 语句的结果是 Unit 类型()
（4）因为 while 中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免
的使用变量，而变量需要声明在 while 循环的外部，那么就等同于循环的内部对外部的变量
造成了影响，所以不推荐使用，而是推荐使用 for 循环。
2）例
|
def main(args: Array[String]): Unit = {
var i = 0
while (i < 10) {
println( i)
i += 1
}
}
|
 |
4.2 do..while 循环控制
1）基本语法
循环变量初始化;
do{
循环体(语句)
循环变量迭代
} while(循环条件)
说明
（1）循环条件是返回一个布尔值的表达式
（2）do..while 循环是先执行，再判断
2）例
|
def main(args: Array[String]): Unit = {
var i = 0
do {
println(i)
i += 1
} while (i < 10)
}
|
 |
5. 循环中断
1）基本说明
Scala 内置控制结构特地去掉了 break 和 continue，是为了更好的适应函数式编程，推
荐使用函数式的风格解决break和continue的功能，而不是一个关键字。Scala中使用breakable
控制结构来实现 break 和 continue 功能。
2）例
采用异常的方式退出循环
|
def main(args: Array[String]): Unit = {
try {
for (elem <- 1 to 10) {
println(elem)
if (elem == 5) throw new RuntimeException
}
}catch {
case e =>
}
println("正常结束循环")
}
|
 |
采用 Scala 自带的函数，退出循环
|
def main(args: Array[String]): Unit = {
Breaks.breakable(
for (elem <- 1 to 10) {
println(elem)
if (elem == 5) Breaks.break()
}
)
println("正常结束循环")
}
|
 |
对 break 进行省略
|
def main(args: Array[String]): Unit = {
breakable {
for (elem <- 1 to 10) {
println(elem)
if (elem == 5) break
}
}
println("正常结束循环")
}
|
 |
循环遍历 10 以内的所有数据，奇数打印，偶数跳过（continue）
|
def main(args: Array[String]): Unit = {
for (elem <- 1 to 10) {
if (elem % 2 == 1) {
println(elem)
} else {
println("continue")
}
}
}
|
 |
6.多重循环
1）基本说明
（1）将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do…while
均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过 3 层】
（2）设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。
2）例
打印出九九乘法表
|
def main(args: Array[String]): Unit = {
for (i <- 1 to 9) {
for (j <- 1 to i) {
print(j + "*" + i + "=" + (i * j) + "\t")
}
println()
}
}
|
输出结果：
 |