在程序中,程序运行的流程控制决定程序是如何执行的,是我们必须掌握的,主要有三大流程控制语句。
温馨提示: Scala语言中控制结构和Java语言中的控制结构基本相同,在不考虑特殊应用场景的情况下,代码书写方式以及理解方式都没有太大的区别
1)顺序控制
2)分支控制(单分支, 双分支,多分支)
3)循环控制
程序从上到下逐行地执行,中间没有任何判断和跳转。
Scala中定义变量时采用合法的前向引用。如:
def main(args : Array[String]) : Unit = {
var num1 = 12
var num2 = num1 + 2
}
错误形式:
def main(args : Array[String]) : Unit = {
var num2 = num1 + 2
var num1 = 12
}
让程序有选择的的执行,分支控制有三种:
1)单分支
2)双分支
3)多分支
基本语法
if (条件表达式) {
执行代码块 }
说明:当条件表达式为ture 时,就会执行 { } 的代码。
基本语法
if (条件表达式) {
执行代码块1 } else {
执行代码块2 }
说明:当条件表达式成立,即执行代码块1,否则执行代码块2.
判断一个年份是否是闰年,闰年的条件是符合下面二者之一:(1)年份能被4整除,但不能被100整除;(2)能被400整除
object IfElseDemo {
def main(args: Array[String]): Unit = {
/*
判断一个年份是否是闰年,闰年的条件是符合下面二者之一:(1)年份能被4整除,但不能被100整除;(2)能被400整除
分析
1. 有一个变量,保存year
2. 分支控制
3. (1) 和 (2) 条件是 或的关系
4. (1) 中的两个条件是 与的关系
代码
*/
var year = 2020
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
println("year=" + year + "是闰年")
} else {
println("year=" + year + "不是闰年")
}
}
}
//多分支案例练习
/*
岳小鹏参加scala考试,他和父亲岳不群达成承诺:
如果:
成绩为100分时,奖励一辆BMW;
成绩为(80,99]时,奖励一台iphone7plus;
当成绩为[60,80]时,奖励一个 iPad;
其它时,什么奖励也没有。
说明: 成绩在控制台输入!
分支
1. 有一个变量 score 保存我们的成绩
2. 使用多分支来控制流程
3. 根据不同的情况,来输出结果
*/
println("请输入岳小鹏考试成绩")
val score = StdIn.readFloat() //大数据
if (score >= 100) {
println("成绩为100分时,奖励一辆BMW")
} else if (score > 80 ) {
println("奖励一台iphone7plus")
} else if (score >= 60) {
println("奖励一个 iPad")
} else {
println("什么奖励也没有")
}
1)如果大括号{}内的逻辑代码只有一行,大括号可以省略, 这点和java 的规定一样。
2)Scala中任意表达式都是有返回值的,也就意味着if else表达式其实是有返回结果的,具体返回结果的值取决于满足条件的代码体的最后一行内容.[案例演示]
3)Scala中是没有三元运算符,因为可以这样简写,使用 if – else
在一个分支结构中又完整的嵌套了另一个完整的分支结构,里面的分支的结构称为内层分支外面的分支结构称为外层分支。嵌套分支不要超过3层
if(){
if(){
}else{
}
}
参加百米运动会,如果用时8秒以内进入决赛,否则提示淘汰。并且根据性别提示进入男子组或女子组。【可以让学员先练习下5min】, 输入成绩和性别,进行判断。1分钟思考思路
double second; char gender;
代码
import scala.io.StdIn
object Exercise03 {
def main(args: Array[String]): Unit = {
/*
参加百米运动会,如果用时8秒以内进入决赛,否则提示淘汰。并且根据性别提示进入男子组或女子组。【可以让学员先练习下5min】, 输入成绩和性别,进行判断
分析
1. 有两个变量
2. 使用到嵌套分支
*/
println("请输入成绩")
val second = StdIn.readFloat()
if (second <= 8 ) {
println("请输入性别")
val gender = StdIn.readChar()
if (gender == '男') {
println("进入男子组决赛")
}else {
println("进入女子组决赛..")
}
}else {
println("你被淘汰...")
}
}
}
出票系统:根据淡旺季的月份和年龄,打印票价 [考虑学生先做5min]
scala 没有switch
4_10 旺季:
成人(18-60):60
儿童(<18):半价
老人(>60):1/3
淡季:
成人:40
其他:20
代码
object Exercise04 {
def main(args: Array[String]): Unit = {
/*
分析
1. 定义月份,年龄,票价
2. 使用嵌套分支业务处理
*/
val (month, age, ticket) = (8, 20, 60.0)
var buyPrice = 0.0
if (month >= 4 && month <= 10) {
if (age >= 18 && age <= 60) {
buyPrice = ticket
} else if (age < 18) {
buyPrice = ticket / 2
} else {
buyPrice = ticket / 3
}
} else {
if (age >= 18 && age <= 60) {
buyPrice = 40.0
} else {
buyPrice = 20.0
}
}
println("应付" + buyPrice)
}
}
在scala中没有switch,而是使用模式匹配(match-case )来处理。后面再写
Scala 也为for 循环这一常见的控制结构提供了非常多的特性,这些for 循环的特性被称为for 推导式(for comprehension)或for 表达式(for expression)
如代码所示:
package com.zpark.bigdata.scala.chapter04
object Scala03_For {
def main(args: Array[String]): Unit = {
// TODO Java中for循环
/*
for (int i = 0;i<10;i++){
循环体
}
for (String s : strings ) {
循环体
}
*/
// TODO Scala中for循环
//使用 1to5 表示循环的范围,1到5。 1.to(5) --> 对象.方法
for(i <- 1 to 5){
println(s"i = ${i}")
}
//使用 1until5 表示循环的范围,1截止到5(不包含5)。 1.until(5) --> 对象.方法
for(i2 <- 1 until 5){
println(s"i2 = ${i2}")
}
//Range(start,end,step) step:以2个增长模式增加
for (i3<-Range (1,5,2)){
println(s"i3 = ${i3}")
}
//嵌套循环
for(i1<-1 to 3){
for(j<- 1 until 3){
println(s"${i1} = ${j}")
}
}
//九成妖塔
for(i <- Range(1,18,2)){
println(" "*((18-i)/2)+ "*"*i+" "*((18-i)/2))
}
}
}
}
所谓循环守卫就是增加条件判断,如果条件成立,那么执行循环体,如果不成立,跳过循环体
1)循环守卫,即循环保护式(也称条件判断式,守卫)。保护式为true则进入循环体内部,为false则跳过,类似于continue
2)上面的代码等价
这种写思路更清晰一点
for (i<-1 to 3){
if ( i != 2) {
println(i+" ")
}
}
基本案例
for(i <- 1 to 3; j = 4 - i) {
print(j + " ")
}
对基本案例说明
1)没有关键字,所以范围后一定要加;来隔断逻辑
2)上面的代码等价
for (i <- 1 to 4) {
val j = 4 - i
println(s"i=ij= {i} j=ij={j}")
}
也可以写成(scala中推荐使用)
for{i <- 1 to 4
j=4-i} {
println(s"i=ij= {i} j=ij={j}")
}
基本案例
for(i <- 1 to 3; j <- 1 to 3) {
println(" i =" + i + " j = " + j)
}
对基本案例说明
1)没有关键字,所以范围后一定要加;来隔断逻辑
2)上面的代码等价(处理比较复杂的业务时,使用这个)
for (i <- 1 to 3) {
for (j <-1 to 3) {
println(“ok”)
}
}
代码
object MutiFor {
def main(args: Array[String]): Unit = {
for (i <- 1 to 3; j <- 1 to 3) {
println(s"i=$i j=$j")
}
//等价的写法
println("================")
for (i <- 1 to 3) {
for (j <- 1 to 3) {
println(s"i=$i j=$j")
}
}
}
基本案例
val res = for(i <- 1 to 10) yield i * 2
println(res)
对基本案例说明
将遍历过程中处理的结果返回到一个新Vector集合中,使用yield关键字,yield 可以写代码块.
代码
//循环返回值
//默认情况下,for循环的返回值为()
//TODO 特殊情况采用yield关键字,表示把每一次循环的结果放到集合当中返回
val res = for(i <- 1 to 10) yield i * 2
println(res)
基本案例
for(i <- 1 to 3; j = i * 2) {
println(" i= " + i + " j= " + j)
}
可以写成:
对基本案例说明
1){}和()对于for表达式来说都可以
2)for 推导式有一个不成文的约定:当for 推导式仅包含单一表达式时使用圆括号,当其包含多个表达式时使用大括号
3)当使用{} 来换行写表达式时,分号就不用写了
4)代码:
object ForDemo03 {
def main(args: Array[String]): Unit = {
for {i <- 1 to 3
j = i * 2} {
println(" i= " + i + " j= " + j)
}
}
1)scala 的for循环形式和java是较大差异,这点请同学们注意,但是基本的原理还是一样的。
2)scala 的for循环的步长如何控制! [for(i <- Range(1,3,2)]
3)思考题:如何使用循环守卫控制步长
4)代码实现
object ForStep {
def main(args: Array[String]): Unit = {
//遍历 1-10, 步长为 3
//方式1 使用Range, 他是一个集合
//说明 1: start
// 10: end 遍历到(end -1)
// 3: 表示step
for (i <- Range(1,10,3)) { //until
println("i=" + i)
}
//灵活的使用守卫 [推荐]
println("==========使用守卫控制步长==============")
for (i <- 1 to 10 if i % 3 == 1 ) {
println("i=" + i)
}
}
直接上代码:
//中断循环
//Java中采用的是break语法
//Scala中没有break关键字,但是她可以采用对象的方式来中断循环
//Breaks.breakable{} 它的作用就是将可能抛异常的放在括号里,这样不会中断代码,还会继续运行下边的。类似于try..cath
Breaks.breakable{
for(i <- 1 to 10){
if (i == 5){
Breaks.break()
}
println(s"${i}")
}
}
println("循环终止")
第二种方法:
// TODO import scala.util.control.Breaks._ 加上._后,原来的Breaks就可以省略了,直接写成如下代码
breakable{
for(i <- 1 to 10){
if (i == 5){
break()
}
println(s"${i}")
}
}
println("循环终止")
循环变量初始化 //循环的四个要素
while (循环条件) {
循环体(语句)
循环变量迭代
}
画出流程图
输出10句"你好,世界"
代码如下:
object WhileDemo01 {
def main(args: Array[String]): Unit = {
//输出10 hello
var n = 1
while (n <= 10) {
println("hello,world" + n)
n += 1 //循环遍历的迭代
}
}
1)循环条件是返回一个布尔值的表达式
2)while循环是先判断再执行语句
3)与If语句不同,While语句本身没有值,即整个While语句的结果是Unit类型的()
4)因为while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量 ,而变量需要声明在while循环的外部,那么就等同于循环的内部对外部的变量造成了影响,所以不推荐使用,而是推荐使用for循环。(scala设计者理念:能使用for循环,就先考虑使用.)
循环变量初始化;
do{
循环体(语句)
循环变量迭代
} while(循环条件)
画出流程图
输入10 “你好,世界”
object DoWhile {
def main(args: Array[String]): Unit = {
//统计1——200之间能被5整除但不能被3整除的个数
//do..while 循环的四要素
var n = 1
var max = 200
var count = 0
do {
if (n % 5 == 0 && n % 3 != 0) {
count += 1
}
n += 1
}while(n <= max)
println("count=" + count)
}
1.循环条件是返回一个布尔值的表达式
2.do..while循环是先执行,再判断
3.和while 一样,因为do…while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量 ,而变量需要声明在do...while循环的外部,那么就等同于循环的内部对外部的变量造成了影响,所以不推荐使用,而是推荐使用for循环
1)统计三个班成绩情况,每个班有5名同学,求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
2)统计三个班及格人数,每个班有5名同学。
3)代码
import scala.io.StdIn
object Exercise06 {
def main(args: Array[String]): Unit = {
/*
1统计三个班成绩情况,每个班有5名同学,求出各个班的平均分和所有班级的平均 分[学生的成绩从键盘输入]。
2.统计三个班及格人数,每个班有5名同学。
思路分析
1. 定义变量 classNum , stuNum , classTotalScore, totalScore, passStuNum
2. 因为没有数组,所以每次输入完一个班级的成绩后,就立即得到结果
3. 会使用到嵌套循环.
*/
val classNum = 3
val stuNum = 5
var classTotalScore = 0.0
var totalScore = 0.0
var stuScore = 0.0
var passStuNum = 0
for (i <- 1 to classNum) {//遍历三个班
//将班级成绩清0.0
classTotalScore = 0.0
for (j<-1 to stuNum) {//遍历学生
printf("请输入%d班级的第%d个学生的成绩\n" , i, j)
stuScore = StdIn.readDouble()
//累计及格的学生个数
if (stuScore >= 60) {
passStuNum += 1
}
//累计到 classTotalScore
classTotalScore += stuScore
}
//得到班级的总成绩
printf("第%d个班的平均成绩为%.2f\n", i, classTotalScore / stuNum)
//累计到totalScore, 为了计算所有班级的总成绩
totalScore += classTotalScore
}
//统计所有班级的平均分
printf("总有班级的平均分为%.2f\n", totalScore / (classNum * stuNum))
printf("及格的人数有%d\n", passStuNum)
}
1. 将一个循环放在另一个循环体内,就形成了嵌套循环。其中,for ,while ,do…while均可以作为外层循环和内层循环。【建议一般使用两层,最多不要超过3层】
2.实质上,嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时,才会完全跳出内层循环,才可结束外层的当次循环,开始下一次的循环。
3.设外层循环次数为m次,内层为n次, 则内层循环体实际上需要执行 m * n次。