内建控制-循环语句while

一. while循环

练习

问题：如何把"i miss you "重复输出3000次？

object base19 {
  def main(args: Array[String]): Unit = {
    // 把 I miss you 重复输出 3000次
    // while 循环的基本格式
/*

    var i = 0 // 循环变量，控制重复的次数
    while (条件){
      循环体
      i += 1
    }
*/

    var i = 1
    while (i <= 3000){
      println(s"${i}. I miss you")
      i += 1
    }
  }
}

问题：输出1~100内的奇数，每个一行

object base20 {
  def main(args: Array[String]): Unit = {
    // 把 1,2,3,4,5,...100 中的奇数输出
    var i = 1
    
    方法一：
    
    while(i<=100){
        println(i) // println重复了100次
      i += 2
    }
    
    方法二：
    while(i<=100){
      if (i % 2 != 0) {
        println(i) // println重复了100次
      }
      i += 1
    }
  }
}

问题：求1-100的和

object base21 {
  def main(args: Array[String]): Unit = {
    // 1 + 2 + 3 + 4 + 5 + ...... + 100 的结果
    // 等差数列： (100+1) * 100 / 2 = 5050
    var sum = 0
    var i = 1
    while (i<=100){
      sum = sum + i
      i += 1
    }
    println(s"sum=${sum}")
  }
}

问题：求 1-100 的奇数和

object base21 {
  def main(args: Array[String]): Unit = {
    // 1 + 2 + 3 + 4 + 5 + ...... + 100 的结果
    // 等差数列： (100+1) * 100 / 2 = 5050
    // 求 1-100 的奇数和
    
    方法一：
    var sum = 0
    var i = 1
    while (i<=100){
      sum = sum + i
      i += 2
    }
    println(s"sum=${sum}")
    
    方法二：
    var sum = 0
    var i = 1
    while (i<=100){
      if(i%2 == 1){
      sum = sum + i
      i += 2
    }
    }
    println(s"sum=${sum}")
  }
}

问题：求 1 + 1/2 + 1/3 + 1/4 + 1/5 + .... + 1/100 的和

object practice03 {
  def main(args: Array[String]): Unit = {
    // 求 1 + 1/2 + 1/3 + 1/4 + 1/5 + .... + 1/100 的和
    var sum:Double = 0
    var i = 1
    while (i<=100){
      sum = sum + 1.0 / i   // 1/2 = 0
      i += 1
    }
    println(s"sum=${sum}")
  }
}

注意：Int与Double的数据类型不同，Int + Double是错误点，应该sum:Double，转换成同一数据类型。

二. while死循环

作用：在需要一直执行的时候，就可以使用死循环。

例如：

不停地判断用户的输入的内容是否是闰年

object base {
  def main(args: Array[String]): Unit = {
    while (true){
      print("请输入要判断的年份（输入 0 就结束判断）：")
      // 判断用户输入的年份，是否为闰年
      val year = scala.io.StdIn.readInt()
      if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)){
        println(s"${year} 是闰年")
      } else {
        println(s"${year} 不是闰年")
      }
    }
  }
}

三. break、

实现方式：

Scala 对 break 的实现方式与传统命令式语言有所不同：

Scala 并没有将 break 作为关键字，而是通过 scala.util.control.Breaks 类提供的工具方法来实现 需要配合 breakable 代码块使用，break 只能在 breakable 块中生效

注意：scala中没有现成的break关键字，而是使用面向对象的方式来代替，底层会抛出异常来跳出循环，外层捕获异常

例如：

问题：输入年份，判断其是否为闰年，并输出判断结果，程序可以终止循环并退出

import scala.util.control.Breaks.{break, breakable}

object base22 {
  def main(args: Array[String]): Unit = {
    breakable{
    while (true){
      print("请输入要判断的年份（输入 0 就结束判断）：")
      // 判断用户输入的年份，是否为闰年
      val year = scala.io.StdIn.readInt()

      if (year == 0){
        // 结束循环
        break
      }

      if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)){
        println(s"${year} 是闰年")
      } else {
        println(s"${year} 不是闰年")
      }
    }
    }
    println("死循环结束了.... 系统退出")
  }
}

注意： 使用 while(true) 实现无限循环， 利用 scala.util.control.Breaks 中的 break 和 breakable 实现循环终止

四. do while循环

object base23 {
  def main(args: Array[String]): Unit = {
    // do while: 无论条件是否成立，都会执行一次！
    // while: 如果条件不成立，不会执行！

/*    var i = 100
    do{
      println(i)
      i += 1
    } while (i<=10)*/

    var i = 100
    while (i<=10){
      println(i)
      i += 1
    }
  }
}

object base24 {
  def main(args: Array[String]): Unit = {
    var i = 0
    var money = 1.0
    /*
    while (i < 20){
      money = money * 1.1
      i = i + 1
    }
    println(s"第${i} 年结束时，有 ${money} 元")
*/
    while (money < 1000) {
      // while(i < 20){
      money = money * 1.8
      // i = i + 1
    }
    println(s"第${i} 年结束时，有 ${money} 元")
  }
}
  // 本金 1 ---- 能力增长 10% ------ 时间 73 ------- 1051
  // 本金 10 ---- 能力增长 10% ------ 时间 73 ------- 1051
  // 本金 1 ---- 能力增长 80% ------ 时间 12 ------- 1051