1. IfElse

1.1 单分支

单独一个if

  1. package chapter04
  3. import scala.io.StdIn
  5. object Test01_IfElse {
  6.   def main(args: Array[String]): Unit = {
  7.     println("请输入您的年龄：")
  8.     val age: Int = StdIn.readInt()
  10.     // 1. 单分支
  11.     println("========= 单分支 =========")
  12.     if (age >= 18) {
  13.       println("成年")
  14.     }
  15.   }
  16. }

1.2 双分支

标准的if-else

  1. package chapter04
  3. import scala.io.StdIn
  5. object Test01_IfElse {
  6.   def main(args: Array[String]): Unit = {
  7.     println("请输入您的年龄：")
  8.     val age: Int = StdIn.readInt()
  10.     //2. 双分支
  11.     println("========= 双分支 =========")
  12.     if (age >= 18) {
  13.       println("成年")
  14.     } else {
  15.       println("未成年")
  16.     }
  17.   }
  18. }

1.3 多分支

if - else if - else，也是很常见的结构

  1. package chapter04
  3. import scala.io.StdIn
  5. object Test01_IfElse {
  6.   def main(args: Array[String]): Unit = {
  7.     println("请输入您的年龄：")
  8.     val age: Int = StdIn.readInt()
  10.     // 3. 多分支
  11.     println("========= 多分支 =========")
  12.     if (age <= 6) {
  13.       println("童年")
  14.     } else if (age < 18) {
  15.       println("青少年")
  16.     } else if (age < 35) {
  17.       println("青年")
  18.     } else if (age < 60) {
  19.       println("中年")
  20.     } else {
  21.       println("老年")
  22.     }
  23.   }
  24. }

1.4 分支的返回值

一切皆对象。那么 if 判断语句到底会给我们返回什么东西呢？
我们甚至还能指定返回值

  1. package chapter04
  3. import scala.io.StdIn
  5. object Test01_IfElse {
  6.   def main(args: Array[String]): Unit = {
  7.     println("请输入您的年龄：")
  8.     val age: Int = StdIn.readInt()
  10.     // 分支语句的返回值
  11.     // 默认是Unit，但是我们可以指定返回值
  12.     println("========= 分支返回值 =========")
  13.     val result: Any = if (age <= 6) {
  14.       println("童年")
  15.       "童年"
  16.     } else if (age < 18) {
  17.       println("青少年")
  18.       "青少年"
  19.     } else if (age < 35) {
  20.       println("青年")
  21.       "青年"
  22.     } else if (age < 60) {
  23.       println("中年")
  24.       age
  25.     } else {
  26.       println("老年")
  27.       age
  28.     }
  29.     println("result: " + result)
  30.   }
  31. }

1.5 三元运算符

这里面没有类似 Java 的三元运算符 a?b:c ，但是我们有其他写法。

  1. package chapter04
  3. import scala.io.StdIn
  5. object Test01_IfElse {
  6.   def main(args: Array[String]): Unit = {
  7.     println("请输入您的年龄：")
  8.     val age: Int = StdIn.readInt()
  10.     // JAVA 中三元运算符 a?b:c
  11.     val res1: String = if (age >= 18) {
  12.       "成年"
  13.     } else {
  14.       "未成年"
  15.     }
  16.     // 另一种写法，更简洁
  17.     val res2 = if (age >= 18) "成年" else "未成年"
  18.   }
  19. }

1.6 嵌套分支

if 里面套 if ，没啥好说的。

  1. package chapter04
  3. import scala.io.StdIn
  5. object Test01_IfElse {
  6.   def main(args: Array[String]): Unit = {
  7.     println("请输入您的年龄：")
  8.     val age: Int = StdIn.readInt()
  10.     // 5. 嵌套分支
  11.     // if 里面套 if
  12.     println("========= 嵌套分支 =========")
  13.     if (age >= 18) {
  14.       println("成年")
  15.       if (age >= 35) {
  16.         if (age > 60) {
  17.           println("老年")
  18.         } else {
  19.           println("中年")
  20.         }
  21.       }
  22.     } else {
  23.       println("未成年")
  24.       if (age <= 6) {
  25.         println("童年")
  26.       } else {
  27.         println("青少年")
  28.       }
  29.     }
  30.   }
  31. }

2. WhileLoop

2.1 while

和普通的While一致。

  1. package chapter04
  3. object Test05_WhileLoop {
  4.   def main(args: Array[String]): Unit = {
  5.     // while
  6.     var a: Int = 10
  7.     while (a >= 1) {
  8.       println("This is a while loop: " + a)
  9.       a -= 1
  10.     }
  11.   }
  12. }

2.2 do-while

do-while的形式，会先执行一次，再进入while判断。

  1. package chapter04
  3. object Test05_WhileLoop {
  4.   def main(args: Array[String]): Unit = {
  5.     // 还是会输出一次
  6.     var b: Int = 0
  7.     do {
  8.       println("This is a do-while loop:" + b)
  9.       b -= 1
  10.     } while (b > 0)
  11.   }
  12. }

3. ForLoop

3.1 范围遍历

注意对比Java的情况。深入一下 to 和 range 以及 until 的源码。

  1. package chapter04
  3. import scala.math.BigDecimal.double2bigDecimal
  5. object Test02_ForLoop {
  6.   def main(args: Array[String]): Unit = {
  7.     /* java for语法：
  8.             for (int i = 0; i < 10; i++){
  9.               System.out.println("Hello World")
  10.             }
  11.      */
  13.     // 1. 范围遍历
  14.     for (i <- 1 to 5) {
  15.       println(i + "hello world")
  16.     }
  18.     /* 更面向对象一些
  19.       这里实际上点进 to ，里面不是Int的方法而是RichInt的方法。
  20.       这里涉及到了 Int 到 RichInt 的隐式转换。
  22.       这里我们得到了 Range下面的Inclusive
  23.      */
  24.     println("===========分割线========")
  25.     for (i <- 1.to(5)) {
  26.       println(i.+(".hello world"))
  27.     }
  29.     // 如果要不包含边界呢？
  30.     // 直接声明range
  31.     println("===========分割线========")
  32.     for (i <- Range(1, 10)) {
  33.       println(i.+(".hello world"))
  34.     }
  36.     println("===========分割线========")
  37.     for (i <- 1 until 5) {
  38.       println(i + "hello world")
  39.     }
  40.   }
  41. }

3.2 集合遍历

如果遍历对象是一个Array、List之类的呢？

  1. package chapter04
  3. import scala.math.BigDecimal.double2bigDecimal
  5. object Test02_ForLoop {
  6.   def main(args: Array[String]): Unit = {
  8.     // 2.集合遍历
  9.     println("\n===========集合遍历========")
  10.     for (i <- Array(12, 34, 53)) {
  11.       println(i)
  12.     }
  13.     for (i <- List(11, 33, 44)) {
  14.       println(i)
  15.     }
  16.     for (i <- Set(112, 333, 22)) {
  17.       println(i)
  18.     }
  19.   }
  20. }

3.3 循环守卫

Scala中不使用 continue关键字，而是用 if 来代替 

  1. package chapter04
  3. import scala.math.BigDecimal.double2bigDecimal
  5. object Test02_ForLoop {
  6.   def main(args: Array[String]): Unit = {
  8.     // 3. 循环守卫
  9.     println("\n===========循环守卫========")
  10.     for (i <- 1 to 10) {
  11.       if (i != 5) {
  12.         println(i)
  13.       }
  14.     }
  16.     for (i <- 1 to 10 if i != 5) {
  17.       println(i)
  18.     }
  19.   }
  20. }

3.4 循环步长

循环中怎么控制步长？注意看 by 的源码

  1. package chapter04
  3. import scala.math.BigDecimal.double2bigDecimal
  5. object Test02_ForLoop {
  6.   def main(args: Array[String]): Unit = {
  8.     // 4. 循环步长
  9.     // 看看源码，其实是通过 Range 实现的
  10.     // step不能为0
  11.     println("\n===========循环步长========")
  12.     for (i <- 1 to 10 by 2) { // 看看源码，by 其实是通过 Range 实现的
  13.       println(i)
  14.     }
  15.     for (i <- 10 to 1 by -2) { // 倒序
  16.       println(i)
  17.     }
  18.     // Double 弃用，使用BigDecimal
  19.     for (i <- 1.0 to 3.0 by 0.5) {
  20.       println(i)
  21.     }
  22.   }
  23. }

3.5 循环嵌套

循环中套循环。当然也有更扁平的写法。

  1. package chapter04
  3. import scala.math.BigDecimal.double2bigDecimal
  5. object Test02_ForLoop {
  6.   def main(args: Array[String]): Unit = {
  8.     // 5. 循环嵌套
  9.     println("\n===========嵌套循环========")
  10.     for (i <- 1 to 3) {
  11.       for (j <- 1 to 3) {
  12.         println("i = " + i + " ,j= " + j)
  13.       }
  14.     }
  15.     println("\n===========嵌套循环2========")
  16.     for (i <- 1 to 2; j <- 1 to 4) {
  17.       println("i = " + i + " ,j= " + j)
  18.     }
  19.   }
  20. }

3.6 循环引入变量

循环中引入一个相关变量。

  1. package chapter04
  3. import scala.math.BigDecimal.double2bigDecimal
  5. object Test02_ForLoop {
  6.   def main(args: Array[String]): Unit = {
  8.     // 6. 循环引入变量
  9.     println("\n==========循环引入变量===========")
  10.     for (i <- 1 to 10) {
  11.       val j = 10 - i
  12.       println("i = " + i + " ,j= " + j)
  13.     }
  15.     for (i <- 1 to 10; j = 10 - i) {
  16.       val j = 10 - i
  17.       println("i = " + i + " ,j= " + j)
  18.     }
  20.     for {
  21.       i <- 1 to 10
  22.       j = 10 - i
  23.     } {
  24.       println("i = " + i + " ,j= " + j)
  25.     }
  26.   }
  27. }

3.7 循环返回值

循环的返回值，在Scala中一般默认为空。但是我们可以使用 yield 关键字。

  1. package chapter04
  3. import scala.math.BigDecimal.double2bigDecimal
  5. object Test02_ForLoop {
  6.   def main(args: Array[String]): Unit = {
  8.     // 7. 循环返回值
  9.     // for 循环在默认情况下返回值都为空
  10.     println("\n==========循环返回值===========")
  11.     val a: Unit = for (i <- 1 to 10) {
  12.       println(i)
  13.     }
  14.     println("a = " + a)  // 空括号
  16.     val b:IndexedSeq[Int] = for (i <- 1 to 10) yield i
  17.     println("b = " + b)
  18.   }
  19. }

4. Break

4.1 Java中的Break

  1. public class TestBreak {
  2.     public static void main(String[] args) {
  3.         try {
  4.             for (int i = 0; i < 5; i++) {
  5.                 if (i == 3)
  6.                     // break;
  7.                     throw new RuntimeException();
  8.                 System.out.println(i);
  9.             }
  10.         } catch (Exception e) {
  11.             // 什么都不做，只是退出循环
  12.         }
  13.         System.out.println("这是循环外的代码");
  14.     }
  15. }

4.2 普通抛异常

Scala里面没有所谓的 break 关键字来跳出循环，但是我们可以通过抛异常的方式来达到同样的效果。

  1. package chapter04
  3. object Test06_Break {
  4.   def main(args: Array[String]): Unit = {
  5.     println("========= 抛异常退出循环  ========")
  6.     // 1. 采用抛异常的形式退出循环
  7.     try {
  8.       for (i <- 0 until 5) {
  9.         if (i == 3)
  10.           throw new RuntimeException
  11.         println(i)
  12.       }
  13.     } catch {
  14.       case e: Exception => // 什么都不做，只是退出循环
  15.     }
  16.     println("这是循环外的代码")
  17.   }
  18. }

4.3 使用Breaks类

上面那种写法还是有点累，我们现在使用一个更简单的写法。

  1. package chapter04
  3. import scala.util.control.Breaks
  4. import scala.util.control.Breaks.break
  6. object Test06_Break {
  7.   def main(args: Array[String]): Unit = {
  8.     println("========= 抛异常退出循环  ========")
  9.     // 2. 使用Scala中 Breaks 类的 break 方法，实现异常的抛出和捕捉
  10.     // 不使用关键字，而是用方法来做Break，这样更面向对象
  11.     Breaks.breakable(
  12.       for (i <- 0 until 5) {
  13.         if (i == 3)
  14.           Breaks.break()
  15.         println(i)
  16.       }
  17.     )
  19.     Breaks.breakable(
  20.       for (i <- 0 until 5) {
  21.         if (i == 3)
  22.           break()
  23.         println(i)
  24.       }
  25.     )
  26.     println("这是循环外的代码")
  27.   }
  28. }