6 流程控制
6.1 分支控制
scala中的表达式都是有返回值的。
返回值为满足条件的最后一行的代码的执行结果。
Scala是基于Java语言开发的,所以是强类型语言。
表达式的返回值
object TestIf_Else {
def main(args: Array[String]): Unit = {
val season = "spring"
//将if-elseif-else的结果赋值给变量result
val result = if (season == "spring")
"spring"
else if (season == "summer")
"summer"
else if (season == "autumn")
"autumn"
else
"winter"
println(result)
}
}
单分支:if
object TestIf {
def main(args: Array[String]): Unit = {
val name = "Tom and Jerry"
val age = 28
//if的逻辑语句只有一行可以省略大括号,java也是
if (age > 18)
println(name)
if (age < 18){
println("too young")
}
}
}
双分支:if - else
object TestIfElse {
def main(args :Array[String]) : Unit = {
val name = "Tom"
val age = 28
if(age > 18)
println(s"name: $name, age: bigger than 18")
else
println(s"""name: $name, age: $age""")
}
}
多分支:if - else if - else
object TestIf_Else {
def main(args : Array[String]) : Unit = {
val season = "spring"
//注意scala中的==是做了非空校验的equals()
if (season=="spring"){
println(s"now is spring !")
}else if (season.equals("summer")){
println(s"now is summer !")
}else if (season=="autumn"){
println(s"now is autumn !")
}else{
println(s"now is winter !")
}
}
}
6.2 循环控制
①for循环
for循环的语句:for(循环变量 <- 数据集){ 循环体 }
这里的数据集可以是任意类型的数据集合,比如字符串,集合,数组等。
object TestFor {
def main(args : Array[String]):Unit ={
1//① Range()
for (i <- Range(1, 5)){
println(i) //1 2 3 4 不包括5,和python的range一样
}
println("=============================")
//② to
for (i <- 1 to 5){
println(i) //1 2 3 4 5
}
println("=============================")
//③ until
for (i <- 1 until 5){
println(i) //1 2 3 4 不包含5
}
println("==============================")
//遍历字符串
for (i <- "string"){
println(i)
}
println("===============================")
//遍历集合
var list = 1 to 5
for(i <- list){
println(i) //1 2 3 4 5
}
}
}
循环步长
object TestFor2 {
def main(args: Array[String]): Unit = {
/*
* Java 中的
* for(int i= 0; i <= 10; i+=2){}
* 这样是每两个数,执行一次循环
* */
//①方式1 to by
for (i <- 0 to 10 by 2){
println(i) //0 2 4 6 8 10
}
//② 方式2 until by
for (i <- 0 until 10 by 2){
println(i) //0 2 4 6 8
}
//③ 方式3 range
for (i <- Range(0, 10, 2)){
println(i) //0 2 4 6 8
}
}
}
循环守卫
object TestFor3 {
def main(args: Array[String]): Unit = {
//输出1-10以内的所有的偶数
for (i <- Range(1, 11)) {
if (i % 2 == 0) {
println(i)
}
}
//在scala中使用循环守卫,更方便
//另外if后面如果是一条执行语句可以省略小括号
for (i <- Range(1, 11) if i % 2 == 0) {
println(i)
}
}
}
倒叙的循环呢?
object TestFor4 {
def main(args: Array[String]): Unit = {
//方式1:range(5, 0, -1)
for (i <- Range(5, 0, -1)) {
println(i)
}
//方式2:do by
for (i <- 5 to 1 by -1) {
println(i)
}
//方式3:until by
for (i <- 5 until (0) by (-1)) {
println(i)
}
}
}
用for循环实现九层妖塔
注意!字符串可以*一个数字,表示这个字符串重复多少次
必须是字符串在前,数字在后
object TestYaoTa {
def main(args: Array[String]): Unit = {
for (i <- Range(1, 10)) {
println((" " * (10 - i)) + ("*" * i) + ("*" * (i - 1)))
}
}
}
②while循环
while循环
object TestWhile {
def main(args: Array[String]): Unit = {
var i = 1
while ( i > 5){
println(i)
i += 1
}
}
}
do-while循环
object ScalaLoop {
def main(args: Array[String]): Unit = {
var i = 5
do {
println(i)
} while ( i < 5 )
}
}
③循环中断
scala中没有continue关键字,break关键字也没有,但是功能不能少
scala采用面向对象的方式实现break操作
import scala.util.control.Breaks
object TestBreak {
def main(args: Array[String]): Unit = {
//Breaks.break()会抛出异常,会改变了逻辑
//把可能会终端的程序放在Breaks.breakable{}内。真的类似于try
//Breaks.break():采用抛出异常的方式改变循环操作。
//Breaks.breakable():采用捕捉异常的方式来处理break方法带来的异常。
Breaks.breakable{
for(i <- Range(0, 10)){
if (i == 5){
Breaks.break()
}
println(i)
}
}
}
}
如果导包:import scala.util.control.Breaks._表示需要Breaks内的哪个包就导入哪个包,那么就可以省略包名。
import scala.util.control.Breaks._
object TestBreak {
def main(args: Array[String]): Unit = {
//Breaks.break()会抛出异常,会改变了逻辑
//把可能会终端的程序放在Breaks.breakable{}内。真的类似于try
breakable{
for(i <- Range(0, 10)){
if (i == 5){
break()
}
println(i)
}
}
}
}
④嵌套循环
嵌套循环
object TestFor6 {
def main(args: Array[String]): Unit = {
var list = Array(11, 24, 44, 22, 55, 20, 39, 21)
//冒泡排序
for (i <- Range(0, list.length); j <- Range(0, list.length-i-1)){
if(list(j) > list(j + 1)){
var temp = list(j + 1)
list(j + 1) = list(j)
list(j) = temp
}
}
println(java.util.Arrays.toString(list))
}
}
object BubbleSort {
def main(args: Array[String]): Unit = {
var list = Array(12, 33, 28, 10, 38, 21, 34)
//冒泡排序
for (i <- Range(0, list.length)) {
for (j <- Range(0, list.length - i - 1)){
if (list(j) > list(j + 1)){
var temp = list(j + 1)
list(j + 1) = list(j)
list(j) = temp
}
}
}
//输出结果
for (i <- list.indices){
println(list(i))
}
}
}
引入变量
object TestFor7 {
def main(args: Array[String]): Unit = {
for (i <- Range(1, 6)) {
var j = i + 1
println(j)
}
//循环中引入变量
for (i <- 1 until 6; j = i + 1) {
println(j)
}
}
}
⑤循环返回值yield
yield关键字可以将循环体的每一个执行结果返回,使用Vector集合接收
如果使用yield关键字,那么循环的返回值将是()也就是Unit
object TestFor8 {
def main(args: Array[String]): Unit = {
val result = for (i <- Range(1, 6)) {
i * 2
}
println(result) //()
//yield关键字可以将循环体的每一个执行结果返回,使用Vector集合接收
val result2 = for (i <- Range(1, 6)) yield {
i * 2
}
println(result2) //Vector(2, 4, 6, 8, 10)
}
}
yield是作为scala的一个关键字,那么调用Thread的yield方法怎么调用呢?
需要加``飘号
Thread.`yield`()