文章目录
4.1 分支控制 if - else
让程序有选择的执行,分支控制有三种:单分支、双分支、多分支
4.1.1 单分支
1)基本语法
if(条件表达式){
执行代码块
}
- 1
- 2
- 3
说明:当条件表达式为true时,就会执行{ }的代码。
2)案例实操
//需求:输入人的年龄,如果该同志的年龄小于18岁,则输出”童年“
object TestIfElse {
def main(args: Array[String]): Unit = {
println(“input age:”)
var age = StdIn.readShort()
if (age < 18){
println(“童年”)
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
4.1.2 双分支
1)基本语法
if(条件表达式){
执行代码块1
}else{
执行代码块2
}
- 1
- 2
- 3
- 4
- 5
2)案例实操
//需求:输入年龄,如果年龄小于18岁,则输出”童年“。否则,输出”成年“。
object TestIfElse {
def main(args: Array[String]): Unit = {
println("input age:")
var age = StdIn.readShort()
if (age < 18){
println("童年")
}else{
println("成年")
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
4.1.3 多分支
1)基本语法
if(条件表达式1){
执行代码块1
}else if(条件表达式2){
执行代码块2
}
......
else{
执行代码块n
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
2)案例实操
2.1 需求 1:需求:输入年龄,如果年龄小于 18 岁,则输出“童年”。如果年龄大于等于 18 且小于等于 30,则输出“中年”,否则,输出“老年”。
object TestIfElse {
def main(args: Array[String]): Unit = {
println("input age")
var age = StdIn.readInt()
if (age < 18){
println("童年")
}else if(age>=18 && age<30){
println("中年")
}else{
println("老年")
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
2.2 需求 2:Scala 中 if else 表达式其实是有返回值的,具体返回值取决于满足条件的代码体的最后一行内容。
object TestIfElse {
def main(args: Array[String]): Unit = {
println("input age")
var age = StdIn.readInt()
val res :String = if (age < 18){
"童年"
}else if(age>=18 && age<30){
"中年"
}else{
"老年"
}
println(res)
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
2.3 需求 3:Scala 中返回值类型不一致,取它们共同的祖先类型。
object TestIfElse {
def main(args: Array[String]): Unit = {
println("input age")
var age = StdIn.readInt()
val res:Any = if (age < 18){
"童年"
}else if(age>=18 && age<30){
"中年"
}else{
100
}
println(res)
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
2.4 需求 4:Java 中的三元运算符可以用 if else 实现
如果大括号{}内的逻辑代码只有一行,大括号可以省略,如果省略大括号,if只对最近的一行逻辑代码起作用。
object TestIfElse {
def main(args: Array[String]): Unit = {
// Java
// int result = flag?1:0
// Scala
println("input age")
var age = StdIn.readInt()
val res:Any = if (age < 18) "童年" else "成年"
"不起作用"
println(res)
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
4.2 嵌套分支
在一个分支结构中又完整的嵌套了另一个完整的分支结构,里面的分支的结构称为内层。分支外面的分支结构称为外层分支。嵌套分支不要超过3层。
1)基本语法
if(){
if(){
}else{
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
2)案例实操
需求:如果输入的年龄小于18;返回“童年”。如果输入的年龄大于等于18,需要再判断;如果年龄大于等于18且小于30,返回“中年”;如果其他,返回“老年”。
object TestIfElse {
def main(args: Array[String]): Unit = {
println("input age")
var age = StdIn.readInt()
val res :String = if (age < 18){
"童年"
}else {
if(age>=18 && age<30){
"中年"
}else{
"老年"
}
}
println(res)
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
4.3 Switch分支结构
1、在Scala中没有Switch,而是使用模式匹配来处理
2、模式匹配涉及到的知识点较为综合,因此我们放在后面讲解。
4.4 For循环控制
Scala也为for循环这一常见的控制结构提供了非常多的特性,这些for循环的特性被称为for推导或for表达式。
4.4.1 范围数据循环(To)
1)基本语法
for(i <- 1 to 3){
print(i + " ")
}
println()
//1、i表示循环的变量,<- 规定to
//2、i将会从1-3循环,前后闭合
- 1
- 2
- 3
- 4
- 5
- 6
- 7
2)案例实操
//需求:输出5句“宋宋,告别海狗人参丸吧“
object TestFor {
def main(args: Array[String]): Unit = {
for(i <- 1 to 5){
println("宋宋,告别海狗人参丸吧"+i)
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
4.4.2 范围数据循环(Until)
1)基本语法
for(i <- 1 until 3) {
print(i + " ")
}
println()
//1、这种方式和前面的区别在于i是从1到3-1
//2、即使前闭合后开的范围
- 1
- 2
- 3
- 4
- 5
- 6
- 7
2)案例实操
//需求:输出5句”宋宋,告别海狗人参丸吧“
object TestFor {
def main(args: Array[String]): Unit = {
for(i <- 1 until 5 + 1){
println("宋宋,告别海狗人参丸吧" + i)
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
4.4.3 循环守卫
1)基本语法
for(i <- 1 to 3 if i != 2) {
print(i + " ")
}
println()
- 1
- 2
- 3
- 4
说明:
(1)循环守卫,即循环保护式(也称条件判断式,守卫)。保护式为true则进入循环体内部,为false则跳过,类似于continue。
(2)上面的代码等价
for (i <- 1 to 3){
if (i != 2) {
print(i + " ")
}
}
- 1
- 2
- 3
- 4
- 5
2)案例实操
//需求:输出1到5中,不等于3的值
object TestFor {
def main(args: Array[String]): Unit = {
for (i <- 1 to 5 if i != 3) {
println(i + "宋宋")
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
4.4.4 循环步长
1)基本语法
for (i <- 1 to 10 by 2) {
println("i=" + i)
}
- 1
- 2
- 3
说明:by表示步长
2)案例实操
需求:输出1到10以内的所有奇数
for (i <- 1 to 10 by 2) {
println("i=" + i)
}
- 1
- 2
- 3
输出结果
4.4.5 嵌套循环
1)基本语法
for(i <- 1 to 3; j <- 1 to 3) {
println(" i =" + i + " j = " + j)
}
- 1
- 2
- 3
说明:没有关键字,所以范围后一定要加;来隔断逻辑。
2)基本语法
上面的代码等价
for (i <- 1 to 3) {
for (j <- 1 to 3) {
println("i =" + i + " j=" + j)
}
}
- 1
- 2
- 3
- 4
- 5
4.4.6 引入变量
1)基本语法
for(i <- 1 to 3; j = 4 - i) {
println("i=" + i + " j=" + j)
}
- 1
- 2
- 3
说明:
(1)for推导式一行中有多个表达式时,所以要加;来隔断逻辑
(2)for推导式有一个不成文的约定:当for推导式仅包含单一表达式时使用圆括号,当包含多个表达式时,一般每行一个表达式,并用花括号代替圆括号,如下
for {
i <- 1 to 3
j = 4 - i
} {
println("i=" + i + " j=" + j)
}
- 1
- 2
- 3
- 4
- 5
- 6
2)案例实操
上面的代码等价于
for (i <- 1 to 3) {
var j = 4 - i
println("i=" + i + " j=" + j)
}
- 1
- 2
- 3
- 4
4.4.7 循环返回值
1)基本语法
val res = for(i <- 1 to 10) yield i
println(res)
- 1
- 2
说明:将遍历过程中处理的结果返回到一个新的Vector集合中,使用yield关键字。
注意:开发中很少使用。
2)案例实操
//需求:将原数据中所有值乘以2,并把数据返回到一个新的集合中。
object TestFor {
def main(args: Array[String]): Unit = {
var res = for(i <-1 to 10) yield {
i * 2
}
println(res)
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
输出结果:
Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
4.4.8 倒序打印
1)说明:如果想倒序打印一组数据,可以用reverse。
2)案例实操:
//需求:倒序打印10到1
for(i <- 1 to 10 reverse){
println(i)
}
- 1
- 2
- 3
- 4
4.5 While 和 do…While 循环控制
While 和 do…While 的使用和 Java 语言中用法相同。
4.5.1 While循环控制
1)基本语法
循环变量初始化
while (循环条件) {
循环体(语句)
循环变量迭代
}
- 1
- 2
- 3
- 4
- 5
说明:
(1)循环条件是返回一个布尔值的表达式
(2)while 循环是先判断再执行语句
(3)与 for 语句不同,while 语句没有返回值,即整个 while 语句的结果是 Unit 类型()
(4)因为 while 中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量,而变量需要声明在 while 循环的外部,那么就等同于循环的内部对外部的变量造成了影响,所以不推荐使用,而是推荐使用 for 循环。
2)案例实操
//需求:输出10句“宋宋”
object TestWhile {
def main(args: Array[String]): Unit = {
var i = 0
while (i < 10) {
println(“宋宋” + i)
i += 1
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
4.5.2 do…while 循环控制
1)基本语法
循环变量初始化;
do{
循环体(语句)
循环变量迭代
} while(循环条件)
- 1
- 2
- 3
- 4
- 5
说明
(1)循环条件是返回一个布尔值的表达式
(2)do…while 循环是先执行,再判断
2)案例实操
//需求:输出10句“宋宋,喜欢海狗人参丸”
object TestWhile {
def main(args: Array[String]): Unit = {
var i = 0
do {
println("宋宋,喜欢海狗人参丸" + i)
i += 1
} while (i < 10)
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
4.6 循环中断
1)基本说明
Scala 内置控制结构特地去掉了 break 和 continue,是为了更好的适应函数式编程,推荐使用函数式的风格解决break和continue的功能,而不是一个关键字。Scala中使用breakable控制结构来实现 break 和 continue 功能。
2)案例实操
需求1:采用异常的方式退出循环
def main(args: Array[String]): Unit = {
try {
for (elem <- 1 to 10) {
println(elem)
if (elem == 5) throw new RuntimeException
}
}catch {
case e =>
}
println("正常结束循环")
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
需求 2:采用 Scala 自带的函数,退出循环
import scala.util.control.Breaks
def main(args: Array[String]): Unit = {
Breaks.breakable(
for (elem <- 1 to 10) {
println(elem)
if (elem == 5) Breaks.break()
}
)
println("正常结束循环")
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
需求 3:对 break 进行省略
import scala.util.control.Breaks._ object TestBreak { def main(args: Array[String]): Unit = {
breakable <span class="token punctuation">{<!-- --></span> <span class="token keyword">for</span> <span class="token punctuation">(</span>elem <span class="token keyword"><-</span> <span class="token number">1</span> to <span class="token number">10</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span> println<span class="token punctuation">(</span>elem<span class="token punctuation">)</span> <span class="token keyword">if</span> <span class="token punctuation">(</span>elem <span class="token operator">==</span> <span class="token number">5</span><span class="token punctuation">)</span> break <span class="token punctuation">}</span> <span class="token punctuation">}</span> println<span class="token punctuation">(</span><span class="token string">"正常结束循环"</span><span class="token punctuation">)</span>
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
需求 4:循环遍历 10 以内的所有数据,奇数打印,偶数跳过(continue)
object TestBreak {
def main(args: Array[String]): Unit = {
for (elem <- 1 to 10) {
if (elem % 2 == 1) {
println(elem)
} else {
println("continue")
}
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
4.7 多重循环
1)基本说明
(1)将一个循环放在另一个循环体内,就形成了嵌套循环。其中,for,while,do…while均可以作为外层循环和内层循环。【建议一般使用两层,最多不要超过 3 层】
(2)设外层循环次数为 m 次,内层为 n 次,则内层循环体实际上需要执行 m*n 次。
2)案例实操
需求:打印九九乘法表
object TestWhile {
def main(args: Array[String]): Unit = {
for (i <- 1 to 9) {
for (j <- 1 to i) {
print(j + "*" + i + "=" + (i * j) + "\t")
}
println()
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
输出结果: