Scala内建控制-循环语句for循环

1. for语句的基本格式

2. for和while的区别

3. continue语句

for循环

格式

for ( 循环变量 <- 数据集) { 
  // 循环体代码  
}

for和while的区别

输出1~100

object bye01 {
  def main(args: Array[String]): Unit = {
    /* for v.s. while
    * 1. for 适用于明确知道循环次数 即 循环点
    * 2. while 适用于不知道循环次数的情况
     */

    //1.输出1~100
     for (i <- 1 to 100) {
       println(i)
     }

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

  }
}

循环守卫

可以在循环中添加条件，如果条件成立就执行循环。这个叫循环守卫。

object bye02 {
  def main(args: Array[String]): Unit = {
  /*
  * 循环守卫
  *   当后面条件外部满足的时候，才去执行循环体的内容
  *
  * 格式：
  * for( 循环变量 <- 起点 to 终点 ; if(条件1); if(条件2);...if(条件N); ) {
  *  println(循环变量)
  * }
  *
  */
  // 输出1 ~ 100 中的能整除 2, 3, 4 的数字
  for(i <- 1 to 100 ; if(i%2 == 0) ; if(i%3 == 0) ; if(i%4 == 0) ) {
    println(i)
    }
  }
}

循环步长

如何输出1 ~ 100 之间的奇数

object bye03 {
  def main(args: Array[String]): Unit = {
  /*
  * 循环步长
  *   每次循环之后，循环变量的自增数值
  *
  * 格式：
  * for( 循环变量 <- 起点 to 终点 by 步长 ) {
  *  println(循环变量)
  * }
  *
  */
  // 输出1 ~ 100 中的奇数
    for(i <- 99 to 1 by -2){
      println(i)
    }
  }
}

例题：

从键盘上输入一个数，判断它是不是素数

object bye05 {
  def main(args: Array[String]): Unit = {
    /**
    * 判断素数
    * 素数：只能被1 和 它自己整除的数。
    * 如：2，3，5，7，11，13，17，19...... 97
    * 思路：用 2 ~ (n-1) 依次去除这个数，如果能被整除说明不是素数！
    * 例如：
    * n = 9
    * 1. 2 不能整除
    * 2. 3 能整除（不是素数）

    * n = 35
    * 1. 2 不能整除
    * 2. 3 不能整除
    * 3. 4 不能整除
    * 4. 5 能整除（不是素数）

    * n = 7（2 ~ 6）
    * 1. 2 不能整除
    * 2. 3 不能整除
    * 3. 4 不能整除
    * 4. 5 不能整除
    * 5. 6 不能整除
    *
    */

    var n = 97
    // 假设它是素数
    var isPrime = true
    for(i <- 2 to n-1){
      if(n%i == 0){  // 能整除
        isPrime = false
      }
    }

    if(isPrime){
      println(s"${n}是素数")
    } else {
      println(s"${n}不是素数")
    }
  }
}

循环的返回值

for也可以获取到返回值

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

object bye04 {
  def main(args: Array[String]): Unit = {
    /**
     * break跳出 整个for 循环
     * 格式：
     * breakable {
     *   for( 循环变量 <- 起点 to 终点 ) {
     *
     *     break
     *
     *   }
     *
     * }
     */

    breakable {
      for (i <- 1 to 100) {
        // 如果遇到了第一个能整除9的数字就提前结束循环
        if (i % 9 == 0) {
          // 结束循环
          break
        }
        println(i)
      }
    }
  }
}

continue

在scala中是没有break和continue关键字的，如果一定要用，可以用scala.util.control包下的Breaks类的break

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

object bye05 {
  def main(args: Array[String]): Unit = {
    /**
    * 判断素数
    * 素数：只能被1 和 它自己整除的数。
    * 如：2，3，5，7，11，13，17，19...... 97
    * 思路：用 2 ~ (n-1) 依次去除这个数，如果能被整除说明不是素数！
    * 例如：
    * n = 9
    * 1. 2 不能整除
    * 2. 3 能整除（不是素数）

    * n = 35
    * 1. 2 不能整除
    * 2. 3 不能整除
    * 3. 4 不能整除
    * 4. 5 能整除（不是素数）

    * n = 7（2 ~ 6）
    * 1. 2 不能整除
    * 2. 3 不能整除
    * 3. 4 不能整除
    * 4. 5 不能整除
    * 5. 6 不能整除
    *
    */

    // breakable + break : 优化不是素数的情况，提前结束循环
    // Math.sqrt() : 减少循环的次数

    var n = 97
    // 假设它是素数
    var isPrime = true
    breakable {
      for(i <- 2 to Math.sqrt(n).toInt){
        if(n%i ==0){ // 能整除，结束循环
          println(s"${i}能整除")
          isPrime = false
          break
        }
        println(i)
      }
    }

    if(isPrime){
      println(s"${n}是素数")
    } else {
      println(s"${n}不是素数")
    }
  }
}

小球从100米高处自由落下，着地后又弹回高度的一半再次落下，如此重复。问经过多少次落地后，小球弹起的高度才会低于0.5米？

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

object bye06 {
  def main(args: Array[String]): Unit = {
    /**
     * 弹跳小球
     * 
     */
    var h:Double = 100
    var i = 0

    while(h>=0.5){
      i += 1
      h = h * 0.5
    }
    println(i, h)

    // for(i <- 1 to 10){
    //   h = h * 0.5
    //   println(s"第${i}次落地，高度是 ${h}")
    // }
  }
}