一、流程控制
循环结构、选择结构、循环结构
1、循环结构
从上至下，从左至右，依次执行，系统默认结构
2.选择结构
分类：单分支、双分支、多分支
(1)、单分支
object xuexi {
def main(args: Array[String]): Unit = {
val a = 20
if(a > 15) {
println("成功")
}
}
}
结果: 成功
(2)、双分支
解释：通过判断条件进行分支执行
object xuexi {
def main(args: Array[String]): Unit = {
val a = 10
if(a > 15) {
println("成功")
} else {
println("不成功")
}
}
}
结果：不成功
(3)、多分支
object xuexi {
def main(args: Array[String]): Unit = {
val a = 9
if(a > 15) {
println("成功")
} else if(a == 10){
println("不成功")
} else {
println("可能成功")
}
}
}
结果：可能成功
(4)、注意事项
1.和java一样，在Scala中，如果大括号{}内逻辑之有一行，则大括号可以省略
案例：
val sex = "male"
if(sex = "male") 1 else 0
2.在Scala中，条件表达式也是有返回值的
val result = if(sex == "male") 1 else 0
result 的结果为 1
3.scala里面没有三元表达式
3.嵌套分支
解释：
有时候，我们会涉及到"组合判断"，即一个分支结构中又嵌套了另一个分支结构，这个种写法就叫嵌套分支。
/**
* 定义三个变量a,b,c 分别记录要进行操作的值
* 定义一个变量max,用来记录获取到最大值
* 先判断a是否大于或者等于b
* 条件成立。说明a大于或等于b，接着比较a和c的值，获取最大值，并赋给max
* 条件不成立，说明最大值是b,让b和c再比较大小，赋给max
* 此时打印max是最大值
*/
object test {
def main(args: Array[String]): Unit = {
val a = 10
val b = 20
val c = 30
var max = 0
if (a > b) {
max = if (a >= c) a else c
} else {
max = if (b >= c) b else c
}
print(max)
}
}
4.块表达式
解释：scala中，使用{} 表示一个块表达式
和if一样，块表达式也是有值的
val a = {
println("1+1")
1+1
}
结果： 1+1 //先打印
2 //后执行打印下面的1 + 1
5.循环结构
分类： for循环 while循环 do.while循环
1.for循环
格式：
for(i <- 表达式/数组/集合){
// 逻辑代码
}
案例：
打印十次"Hello,Scala"
object test {
def main(args: Array[String]): Unit = {
val name = 1 to 10
for (i <- name){
println("Hollo,Scala" + i)
}
}
}
结果：
Hollo,Scala1
Hollo,Scala2
Hollo,Scala3
Hollo,Scala4
Hollo,Scala5
Hollo,Scala6
Hollo,Scala7
Hollo,Scala8
Hollo,Scala9
Hollo,Scala10
简化代码：
object test {
def main(args: Array[String]): Unit = {
for (i <- 1 to 10) println("Hollo,Scala" + i) //因为逻辑就一行，可以省略{},结果一样
}
}
2.嵌套循环
解释：循环嵌套循环
案例：
object test {
def main(args: Array[String]): Unit = {
for (i <- 1 to 3) { //外循环控制列
for (j <- 1 to 5) { //内循环控制行
print("*")
}
println("*")
}
}
}
结果：
******
******
******
简化：
object test {
def main(args: Array[String]): Unit = {
for (i <- 1 to 3) {
for (j <- 1 to 5) if (j == 5) println("*") else print("*")
}
}
}
简化2
object test {
def main(args: Array[String]): Unit = {
for (i <- 1 to 3; j <- 1 to 5) if (j == 5) println("*") else print("*")
//scala独有的写法，可以将fot条件放在一个括号里，用;隔开
}
}
3.守卫
解释：for表达式中，可以添加if判断语句，这个if判断就称之为守卫。
格式：
for(i <- 表达式/数组/集合 if 表达式){
//逻辑代码
}
案例：
/**
* 得到1到10被3整除的数
*/
object test {
def main(args: Array[String]): Unit = {
for (i <- 1 to 10 if i % 3 == 0) println(i)
}
}
结果：
3
6
9
4.for推导式
解释：Scala中的for循环也是有返回值的，在for循环体中，可以使用yield表达式构建出一个集合(可以简单理解为：就是一组数据)，我们把使用yield的for表达式称为推导式
/**
* 得到10，20，30，40 ... 100的集合
*/
object test {
def main(args: Array[String]): Unit = {
val nums = for(i <- 1 to 10) yield i * 10
println(nums)
}
}
结果：Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
5.while 循环
解释：和java一样，条件是false循环结束，是true就继续执行循环体
格式：
while (判断条件){
//循环体
//控制条件
}
案例：
object test {
def main(args: Array[String]): Unit = {
var i = 1
while (i <= 10) {
println(i)
i = i + 1
}
}
}
结果：
1
2
3
4
5
6
7
8
9
10
5.do.while 循环
格式：
do{
//循环体
//控制条件
} while(判断条件)
案例：
object test {
def main(args: Array[String]): Unit = {
var i = 1
do {
println(i)
i = i + 1
} while (i <= 10)
}
}
结果：
1
2
3
4
5
6
7
8
9
10
6.实现break
解释：在for循环中，需要推出循环的地方，需要添加break()方法调用
用法：
1.导包
import scala.util.control.Breaks._
2.使用breakable将for表达式包起来
3.for表达式中需要退出循环的地方，添加break()方法
案例：
使用for表达式打印1-10的数据字，但是如果遇到数据5，则退出for表达式
object test {
def main(args: Array[String]): Unit = {
import scala.util.control.Breaks._
breakable(
for (i <- 1 to 10) {
if (i == 5) break() else println(i)
}
)
}
}
结果：
1
2
3
4
7.实现continue
和上面break类似，主要是主要看breakable在什么位置，主要功能式终止本次循环，执行下一次循环
案例：用for表达式打印1-10之间，所有不能整除3的数字
object test {
def main(args: Array[String]): Unit = {
import scala.util.control.Breaks._
for (i <- 1 to 100) {
breakable(
if (i % 3 == 0) break() else println(i)
）
}
}
}