for循环

一、for 循环

1.格式：

for(循环变量 <- 起点 to 终点)

object base21 {
  def main(args: Array[String]): Unit = {
    /*
    for 循环
    格式：
    for(循环变量 <- 起点 to 终点)

    for 循环 and while 循环
    1.for 适用于明确知道循环的起点与终点
    2.while 适用于不确定循环次数的情况
     */
    // 输出1~100
    for (i <- 1 to 100){
      println(i)
    }

    // while 循环输出1~100
    //var i = 1
    //while (i <=100){
   //   println(i)
   //   i+=1
   // }

二、循环守卫

1.当后面的条件都满足时，才去执行循环体内容

2.格式： for(循环变量 <- 起点 to 终点; if(条件1); if(条件2))

object base22 {
  def main(args: Array[String]): Unit = {
    /*
    循环守卫
    当后面的条件都满足时，才去执行循环体内容

    格式：
    for(循环变量 <- 起点 to 终点; if(条件1); if(条件2))
     */

    // 输出1~100之间能整除2，3的数字
    for (i <- 1 to 100; if(i%2==0); if (i%3==0)){
      println(i)
    }


  }

}

三、循环步长

1.每次循环后，循环变量的自增数值

2.格式： for(循环变量 <- 起点 to 终点 by 步长）{ println(循环变量) }

object base23 {
  def main(args: Array[String]): Unit = {
    /*
    循环步长
    每次循环后，循环变量的自增数值

    格式：
    for(循环变量 <- 起点 to 终点 by 步长）{
      println(循环变量)
    }
     */

    // 输出1~100中的奇数
    for (i <- 99 to 1 by -2){
      println(i)
    }
    

  }

}

四、break 跳出 for 循环

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

object base24 {
  def main(args: Array[String]): Unit = {
    /*
    break 跳出 for 循环

    格式：
    breakable{
    for(循环变量 <- 起点 to 终点){
        break
      }
   }
     */

    // 输出1~100之间能整除2，3的数字
    breakable{
      for (i <- 1 to 100){
        //如果遇到第一个能整除9的数字提前结束循环
        if (i%9==0){
          //结束循环
          break
        }
      }
    }



  }

}

五、练习

1.只能被1和它本身整除的数是素数。2 3 5 7 11 13 17 19...

2.可以从2开始到n-1为止，依次去除这个数n，如果能被除，就不是素数。

3.设置一个变量，初始值为true，表示它是一个素数，在循环内部，如果有整除的情况，就把它设置为false。

4.循环结束之后，检查变量的值，看看是不是素数。

object base25 {
    def main(args: Array[String]): Unit = {
      /*
      1.只能被1和它本身整除的数是素数。2 3 5 7 11 13 17 19...
  2.可以从2开始到n-1为止，依次去除这个数n，如果能被除，就不是素数。
  3.设置一个变量，初始值为true，表示它是一个素数，在循环内部，如果有整除的情况，就把它设置为false。
  4.循环结束之后，检查变量的值，看看是不是素数。
       */
      /**
       * 判断素数
       * 素数：只能被1和它本身整除
       * eg:2、3、5、7、11、19.....97
       *
       * 思路：用2~（n-1）依次去除这个数，如果能被整除说明不是素数！
       * 例如：
       *     n=9
       *  1. 2不能整除
       *  2. 3能整除（不是素数）
       *
       *    n=7
       * 1. 2不能整除
       * 2. 3不能整除
       * 3. 4不能整除
       * 4. 5不能整除
       * 5. 6不能整除
       * 所以7是素数！
       *
       */

      val n=35
      // 假设它是素数
      var isPrime = true
      for (i <-2 to n-1){
        if (n%2==0){//能整除
          isPrime = false
        }
      }
      if (isPrime){
        println(s"${n}是素数")
      }else{
        println(s"${n}不是素数")
      }


    }



}

优化

breakable + break :优化不是素数的情况：提前结束

Math.sqrt(n)：减少搜索的范围

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

object base25 {
  def main(args: Array[String]): Unit = {
    /*
      1.只能被1和它本身整除的数是素数。2 3 5 7 11 13 17 19...
  2.可以从2开始到n-1为止，依次去除这个数n，如果能被除，就不是素数。
  3.设置一个变量，初始值为true，表示它是一个素数，在循环内部，如果有整除的情况，就把它设置为false。
  4.循环结束之后，检查变量的值，看看是不是素数。
       */
    /**
     * 判断素数
     * 素数：只能被1和它本身整除
     * eg:2、3、5、7、11、19.....97
     *
     * 思路：用2~（n-1）依次去除这个数，如果能被整除说明不是素数！
     * 例如：
     * n=9
     *  1. 2不能整除
     *     2. 3能整除（不是素数）
     *
     * n=7
     * 1. 2不能整除
     * 2. 3不能整除
     * 3. 4不能整除
     * 4. 5不能整除
     * 5. 6不能整除
     * 所以7是素数！
     *
     */
    // breakable + break :优化不是素数的情况：提前结束
    // Math.sqrt(n)：减少搜索的范围
    val n = 97
    // 假设它是素数
    var isPrime = true
    breakable {
      for (i <- 2 to Math.sqrt(n).toInt) { //开根号
        if (n % 2 == 0) { //能整除
          isPrime = false
          break
        }
        println(i)
      }

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

  }
}

弹跳小球

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

object base26 {
  def main(args: Array[String]): Unit = {
    /**
     * 弹跳小球
     */


    var h:Double =100
    var  i =0

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

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

  }

}