Scala中的while循环语句

1.while的格式是？

2.do... while和while的区别是？

3.scala中如何实现break的效果？

if语句，我们称他为选择结构，那在Scala中有其他的结构吗？ 当然也有，例如循环结构。

（一）while循环

如何把”i miss you ”重复输出3000次？

object Main {
  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 Main {
  def main(args: Array[String]): Unit = {
    var i = 1  // 初始化计数器，从第一个奇数1开始
    
    while (i <= 100) {  // 循环条件：i小于等于100
      println(i)        // 输出当前的奇数
      i += 2           // 每次增加2，跳到下一个奇数
    }
  }
}

求1-100的和

object Main {
  def main(args: Array[String]): Unit = {
    var i = 1
    var sum = 0
    
    while (i <= 100) {
      sum += i  // 累加
      i += 1    // 计数器加1
    }
    
    println(s"1-100的和为：$sum")
  }
}

求1-100的奇数和

object Main {
  def main(args: Array[String]): Unit = {
    var i = 1
    var sum = 0
    
    while (i <= 100) {
      sum += i  // 累加奇数
      i += 2    // 每次加2，跳到下一个奇数
    }
    
    println(s"1-100的奇数和为：$sum")
  }
}

求1+1/2+1/3+...+1/100的和

object Main {
  def main(args: Array[String]): Unit = {
    var i = 1
    var sum = 0.0  // 使用Double类型，因为结果会有小数
    
    while (i <= 100) {
      sum += 1.0 / i  // 注意：使用1.0而不是1，避免整数除法
      i += 1
    }
    
    println(f"1 + 1/2 + 1/3 + ... + 1/100 = $sum%.6f")
  }
}

（二）while死循环

在需要一直执行的时候，就可以使用死循环。例如，不停地判断用户的输入的内容是否是闰年。

下面是运用while死循环来判断年份是否为闰年：

object Main {
  def main(args: Array[String]): Unit = {
    // while死循环
    while (true) {
      println("请输入年份（输入0退出程序）：")
      val input = scala.io.StdIn.readLine()

      if (input == "0") {
        println("程序退出")
        System.exit(0)  // 退出程序
      }

      try {
        val year = input.toInt

        // 判断闰年规则：
        // 1. 能被4整除但不能被100整除
        // 2. 能被400整除
        val isLeapYear = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)

        if (isLeapYear) {
          println(s"$year 年是闰年")
        } else {
          println(s"$year 年不是闰年")
        }
      } catch {
        case e: NumberFormatException =>
          println("输入错误，请输入有效的年份数字！")
      }

      println()  // 空行分隔
    }
  }

死循环是一个种非常使用的结果，它能确保核心逻辑一直被调用中。

（三）break

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

下面是运用break方法来判断年份是否为闰年：

import scala.util.control.Breaks._

object Main {
  def main(args: Array[String]): Unit = {
    breakable {
      while (true) {
        println("请输入年份（输入'0'退出）：")
        val input = scala.io.StdIn.readLine().trim

        if (input.equalsIgnoreCase("0")) {
          println("感谢使用，再见！")
          break()  // 跳出循环
        }

        try {
          val year = input.toInt

          val isLeapYear = if (year % 400 == 0) true
          else if (year % 100 == 0) false
          else if (year % 4 == 0) true
          else false

          val result = if (isLeapYear) "是闰年" else "不是闰年"
          println(s"$year 年$result")

        } catch {
          case e: NumberFormatException =>
            println("输入错误，请输入有效的整数年份！")
        }

        println("-" * 30)
      }
    }
  }
}

通过特殊的语法操作，可以让代码变得简单一些。

（四）do while循环

do ... while 和while的区别在于，一定会执行一次。

例如：

object Main {
  def main(args: Array[String]): Unit = {
    // do-while: 无论条件是否成立，都会执行一次！
    var i = 100
    do {
      println(s"do-while循环执行，i = $i")
      i += 1
    } while(i <= 10)
    
    println("do-while循环结束")
  }
}