1. * java流程控制:<br />    *   分支: if-else \ switch<br />    *   循环: for\while\do-while<br />   * scala中删除了switch分支控制。<br />    * scala中流程控制：<br />    *     分支: if-else<br />    *     循环: for\while\do-while

块表达式

块表达式: 由{ }包裹的一段代码称之为块表达式。
块表达式有返回值,返回值是{ }中最后一个表达式的结果值，看下面代码注释内容。
[ for\while\do-while中的{ }不认定为块表达式 ]

  1. package com.atguigu.chapter04
  3. object $01_Block {
  5.   def main(args: Array[String]): Unit = {
  7.         // 块表达式
  8.     val r = {
  9.       println("..............")
  10.       val x =10
  11.       val y=20
  12.       val z = x+y//如果这句在块表达式最后，那么就没有返回值，因为这个语句是一个赋值过程，而未含有具体结果
  13.       z // z已经获得具体值，可以返回
  14.     }
  17.     30
  18.   }
  19. }

if语句

/*
 【掌握】
分支控制:
条件匹配成功之后不会再运行其他语句。
 1、单分支: if(..){…}
2、双分支: if(..){..} else {..}
 3、多分支: if(..){..} else if(..){..}… else{…}
scala if分支控制有返回值,返回值为符合条件的分支的{ }中最后一个表达式的结果值[块表达式的值]
/

  1. package tcode.chapter04
  3. object $02_If {
  5.   def main(args: Array[String]): Unit = {
  7.     val a = 10
  9.     //单分支，块表达式
  10.     val r = if(a%2==0){
  11.       println("a是2的倍数")
  12.       10
  13.     }
  14.     println(r)
  16.     //双分支
  17.     if(a%3==0){
  18.       println("a是3的倍数")
  19.     }else{
  20.       println("a不是3的倍数")
  21.     }
  23.     //多分支
  24.     val t = if(a%4==0){
  25.       println("a是4的倍数")
  26.       10
  27.     }else if(a%6==0){
  28.       println("a是6的倍数")
  29.       30
  30.     }else{
  31.       if(a%5==0){
  32.         println("a是5的倍数")
  33.         40
  34.       }else{
  35.         println("其他...")
  36.         50
  37.       }
  38.     }
  40.     println(t)// t=40
  41.   }
  42. }

for循环

for两个重要方法
to:左右闭合 until：左闭右开
tart.to(end) 1.to(10)
start to end 1 to 10		 start.until(end) 1.until(10)
start until end 1 until 10
语法
for循环基本语法: for( 变量 <- 数组/集合/表达式 ) { …. }
守卫: for( 变量 <- 数组/集合/表达式 if(布尔表达式) ) { …. }
使用条件：if语句前不能有其他语句
步长: for(变量<- start to/until end by step) {..}
说明：如：by 2 则每隔两个数字循环，1,3,5,7…
嵌套for: for( 变量1 <- 数组/集合/表达式 ;变量2 <- 数组/集合/表达式 ; .. ){…}
嵌套+守卫: for( 变量1 <- 数组/集合/表达式 if(布尔表达式) if(布尔表达式) ..;变量2 <- 数组/集合/表达式 if(布尔表达式); .. ){…}
yield表达式: for( 变量 <- 数组/集合/表达式 ) yield {…}
说明：样for的{}拥有返回值
引入变量：for(变量名<- 集合/数组/表达式；变量3=值；变量2<- start to 变量3)

/*
 for循环两个重要方法:

  1. * for循环基本语法: for( 变量 <- 数组/集合/表达式 ) { .... }<br />    * 守卫: for( 变量 <- 数组/集合/表达式 if(布尔表达式) ) { .... }<br />    * 步长: for(变量<- start to/until end by step) {..}<br />    * 嵌套for: for( 变量1 <- 数组/集合/表达式 ;变量2 <- 数组/集合/表达式 ; .. ){...}<br />    * 嵌套+守卫: for( 变量1 <- 数组/集合/表达式 if(布尔表达式)  if(布尔表达式) ..;变量2 <- 数组/集合/表达式  if(布尔表达式); .. ){...}<br />    * yield表达式: for( 变量 <- 数组/集合/表达式 ) yield {...}<br />    */
  1. package tcode.chapter04
  3. object $03_For {
  6.   def main(args: Array[String]): Unit = {
  8.     // for循环基本语法: for( 变量 <- 数组/集合/表达式 ) { .... }
  9.     for(i<- 1 to 10){
  10.       println(i)
  11.     }
  13.     println( "*" * 100 )
  14.     //for循环嵌套if
  15.     for(i<- 1 to 10){
  16.       //println(s"i*i=${i*i}")
  17.       if(i%2==0){
  18.         println(i)
  19.       }
  20.     }
  21.     println("+"*100)
  22.     //守卫
  23.     for(i<- 1 to 10 if(i%2==0)){
  24.       println(i)
  25.     }
  27.     //步长
  28.     for(i<- 1 to 10 by 2){
  29.       println(s"i=${i}")
  30.     }
  32.     //嵌套for
  33.     for(i<- 1 to 10){
  34.       if(i%2==0){
  35.         for(j<- i to 10){
  36.           println(s"i+j=${i+j}")
  37.         }
  38.       }
  39.     }
  40.     println("-"*100)
  41.     for(i<- 1 to 10 if(i%2==0); j<- i to 10 if(j%4==0)){
  42.       println(s"i*j=${i*j}")
  43.     }
  45.     //yield表达式
  46.     val r = for(i<- 1 to 10) yield {
  47.       println(s"i=${i}")
  48.       i * i
  49.     }
  51.     println(r)
  53.     (1 to 10).foreach(println(_))
  54.   }
  55. }

while

与java完全一致

  1. package tcode.chapter04
  3. object $04_While {
  5.   //【掌握】
  6.   //scala while与do-while完全一样
  7.   def main(args: Array[String]): Unit = {
  9.     var a = 11
  10.     while ( a<=10 ) {
  11.       println(s"a=${a}")
  12.       a=a+1
  13.     }
  15.     var b=11
  16.     do{
  17.       println(s"b=${b}")
  18.       b = b+1
  19.     }while(b<=10)
  20.   }
  21. }

BreakAndContine(了解)

/*
 break: 结束整个循环
continue: 跳出当前循环,开始下一次循环

scala中没有break与continue关键字。
 scala实现break:
1、导包: import scala.util.control.Breaks._
 2、通过breakable、break方法实现
scala实现continue:
 1、导包: import scala.util.control.Breaks._
2、通过breakable、break方法实现
/
breakable相当于try\catch
break方法其实就是java中的抛异常
image.png

  1. package tcode.chapter04
  2. import scala.util.control.Breaks._
  3. object $05_BreakAndContinue {
  5.   def main(args: Array[String]): Unit = {
  7.     //实现break
  8.     var a=1
  9.     try{
  10.       while(a<=10){
  11.         if(a==5) throw new Exception
  12.         println(s"a=${a}")
  13.         a=a+1
  14.       }
  15.     }catch {
  16.       case e:Exception =>
  17.     }
  19.     //实现continue
  20.     a=1
  21.     while(a<=10){
  22.       try{
  24.         if(a==5) throw new Exception
  25.           println(s"a=${a}")
  26.           a=a+1
  27.       }catch {
  28.         case e:Exception => a=a+1
  29.       }
  30.     }
  31.     println("*"*100)
  32.     //scala break实现
  33.     a=1
  34.     breakable( {
  35.       while(a<=10){
  36.         if(a==5) break()
  37.         println(s"a=${a}")
  38.         a=a+1
  39.       }
  40.     } )
  42.     //continue
  43.     a=1
  44.     while(a<=10){
  45.       breakable({
  46.         if(a==5) {
  47.           a=a+1
  48.           break()
  49.         }
  50.         println(s"a=${a}")
  51.         a=a+1
  52.       })
  54.     }
  55.   }
  56. }

迭代器遍历：

（1 until 10).foreach(index=>{…})