和 Java 中的 if-else 一致
-
单分支, 语法：
if (条件表达式) { 执行代码块 }说明：当条件表达式为ture时，就会执行{ }的代码。
需求：输入人的年龄，如果该同志的年龄大于18岁，则输出“age > 18”
object TestIfElse { def main(args: Array[String]): Unit = { println("input age:") var age = StdIn.readShort() if (age > 18){ println("age>18") } } }
-
双分支 语法：
if (条件表达式) { 执行代码块1 } else { 执行代码块2 }
需求：输入年龄，如果年龄大于18岁，则输出“age >18”。否则，输出“age <= 18”。
object TestIfElse { def main(args: Array[String]): Unit = { println("input age:") var age = StdIn.readShort() if (age > 18){ println("age>18") }else{ println("age<=18") } } }
-
多分支 语法：
if (条件表达式1) { 执行代码块1 } else if (条件表达式2) { 执行代码块2 } …… else { 执行代码块n }
需求：岳小鹏参加Scala考试，他和父亲岳不群达成承诺：如果，成绩为100分时，奖励一辆BM；成绩为(80，99]时，奖励一台iphone；其它时，什么奖励也没有。
object TestIfElse { def main(args: Array[String]): Unit = { println("请输入成绩") val grade = StdIn.readInt() if (grade == 100){ println("成绩为100分，奖励一辆BM") }else if (grade > 80 && grade <= 90){ println("奖励一台iphone") }else{ println("什么奖励也没有") } } }
需求：Scala中if else表达式其实是有返回值的，具体返回值取决于满足条件的代码体的最后一行内容。
object TestIfElse { def main(args: Array[String]): Unit = { println("input your age") var age = StdIn.readInt() var res = if(age > 18){ "您以成人" }else{ "小孩子一个" } println(res) } }
和 Java 一样，如果大括号{}内的逻辑代码只有一行，大括号可以省略。
语法
if(){
if(){
}else{
}
}需求：参加百米运动会，根据性别提示进入男子组或女子组。如果是女子组，用时8秒以内进入决赛，否则提示淘汰。
object TestIfElse {
def main(args: Array[String]): Unit = {
println("输入性别：")
var gender = StdIn.readChar()
if (gender == '男'){
println("男子组")
}else{
println("女子组")
println("输入成绩：")
var grade = StdIn.readDouble()
if (grade > 8.0){
println("你被淘汰了")
}else{
println("成功晋级")
}
}
}
}在Scala中没有Switch，而是使用模式匹配来处理。
Scala也为for循环这一常见的控制结构提供了非常多的特性，这些for循环的特性被称为for推导式或for表达式。
语法：
for(i <- 1 to 3){
print(i + " ")
}
println()- i 表示循环的变量，<- 规定to
- i 将会从 1-3 循环，前后闭合
需求：输出10句 "hi, kino"
object TestFor {
def main(args: Array[String]): Unit = {
for(i <- 1 to 10){
println("hi, kino"+i)
}
}
}语法：
for(i <- 1 until 3) {
print(i + " ")
}
println()- 这种方式和前面的区别在于i是从1到3-1
- 即使前闭合后开的范围
语法：
for(i <- 1 to 3 if i != 2) {
print(i + " ")
}
println()-
循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue。
-
上面的代码等价于
for (i <- 1 to 3){
if (i != 2) {
print(i + "")
}
}需求：输出1到10中，不等于5的值
object TestFor {
def main(args: Array[String]): Unit = {
for (i <- 1 to 10 if i != 5) {
println(i + "")
}
}
}语法：
for (i <- 1 to 10 by 2) {
println("i=" + i)
}- by表示步长
需求：输出1到10以内的所有奇数
for (i <- 1 to 10 by 2) {
println("i=" + i)
}结果输出:
i=1
i=3
i=5
i=7
i=9语法：
for(i <- 1 to 3; j <- 1 to 3) {
println(" i =" + i + " j = " + j)
}- 没有关键字，所以范围后一定要加；来隔断逻辑
上面的代码等价(当 第一层循环和 第二层循环 中间没有任何操作时才可以使用上面的代码)
for (i <- 1 to 3) {
for (j <- 1 to 3) {
println("i =" + i + " j=" + j)
}
}语法：
for(i <- 1 to 3; j = 4 - i) {
println("i=" + i + " j=" + j)
}- for推导式一行中有多个表达式时，所以要加；来隔断逻辑
- for推导式有一个不成文的约定：当for推导式仅包含单一表达式时使用圆括号，
- 当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号，如下
for { i <- 1 to 3 j = 4 - i } { println("i=" + i + " j=" + j) }
上面的代码等价于(指的是 语法 展示的代码)
for (i <- 1 to 3) {
var j = 4 - i
println("i=" + i + " j=" + j)
}语法：
val res = for(i <- 1 to 10) yield i
println(res)- 将遍历过程中处理的结果返回到一个新Vector集合中，使用yield关键字
需求：将原数据中所有值乘以2，并把数据返回到一个新的集合中。
object TestFor {
def main(args: Array[String]): Unit = {
var res = for( i <-1 to 10 ) yield {
i * 2
}
println(res)
}
}
输出结果：
Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)语法：
while (循环条件) {
循环体(语句)
循环变量迭代
}- 循环条件是返回一个布尔值的表达式
- while循环是先判断再执行语句
- 与if语句不同，while语句没有返回值，即整个while语句的结果是Unit类型()
- 因为while中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，也就违背了函数式编程的重要思想（输入=>函数=>输出，不对外界造成影响），所以不推荐使用，而是推荐使用for循环。
需求：输出10句 "hi，kino"
object TestWhile {
def main(args: Array[String]): Unit = {
var i = 0
while (i < 10) {
println("hi，kino" + i)
i += 1
}
}
}语法：
do{
循环体(语句)
循环变量迭代
} while(循环条件)- 循环条件是返回一个布尔值的表达式
- do..while循环是先执行，再判断
需求：输出10句 "hi，kino"
object TestWhile {
def main(args: Array[String]): Unit = {
var i = 0
do {
println("hi，kino" + i)
i += 1
} while (i < 10)
}
}需求：打印出九九乘法表
object TestWhile {
def main(args: Array[String]): Unit = {
var max = 9
for (i <- 1 to max) {
for (j <- 1 to i) {
print(j + "*" + i + "=" + (i * j) + "\t")
}
println()
}
}
}可以简写成
object TestWhile {
def main(args: Array[String]): Unit = {
var max = 9
for (i <- 1 to max; j <- 1 to i) {
print(j + "*" + i + "=" + (i * j) + "\t")
if(j == i) println()
}
}
}Scala内置控制结构特地去掉了break和continue，是为了更好的适应函数式编程，推荐使用函数式的风格解决break和continue的功能，而不是一个关键字。scala中使用breakable控制结构来实现break和continue功能。
需求：循环遍历10以内的所有数据，数值为5，结束循环（break）
我们一步步推导出 scala 中使用的 breakable ①
def main(args: Array[String]): Unit = {
try{
for (i <- 1 to 10) {
println(i)
if(i == 5) throw new IllegalArgumentException
}
} catch {
case e =>
}
println("正常输出....")
}输出结果
1
2
3
4
5
正常输出....②
此时已经实现了我们的需求， 但是这样写 手动抛出异常 写 try catch 和麻烦
scala 中 体重了 Breaks 包 来抛出异常以及捕获异常
import scala.util.control.Breaks
def main(args: Array[String]): Unit = {
Breaks.breakable(
for (i <- 1 to 10) {
println(i)
if (i == 5) Breaks.break()
}
)
println("正常输出....")
}③ 我们在 Java 中， 导入某个包下所有类，可以使用 import scala.util.* 指定导入 util 下所有的类，在这里我们也可以批量导入
// scala 中
import scala.util.control.Breaks._
object HelloWorld {
def main(args: Array[String]): Unit = {
breakable(
for (i <- 1 to 10) {
println(i)
// 这里 break() 的括号中无参数， 也可以省略
// if (i == 5) break()
if (i == 5) break
}
)
println("正常输出....")
}
}