轻松入门大数据第15章零基础：极速入门大数据编程首选语言Scala 15.1 Scala基础 15.1.13 【重要必掌握】循环之for

雨点打透心脏的1/2处 2024-03-16 16:22 20阅读 0赞

### 轻松入门大数据 ###

#### 文章目录 ####

*   *  轻松入门大数据
     *   *  第15章 零基础：极速入门大数据编程首选语言Scala
         *   *  15.1 Scala基础
             *   *  15.1.13 【重要必掌握】循环之for

![在这里插入图片描述][90898376d6c74ba19b1f910010efbda4.png_pic_center]

#### 第15章 零基础：极速入门大数据编程首选语言Scala ####

##### 15.1 Scala基础 #####

![在这里插入图片描述][431ca3651106485b87443c05dea73d31.png_pic_center]

> 1.  注释
> 2.  标识符
> 3.  数据类型
> 4.  值和变量
> 5.  数据类型转换
> 6.  字符串操作
> 7.  从控制台读取数据
> 8.  运算符
> 9.  条件分支
> 10. 循环分支
> 11. 方法定义
> 12. 默认参数
> 13. 命名参数
> 14. 变长参数

###### 15.1.13 【重要必掌握】循环之for ######

工作中常用，官网文档：[https://docs.scala-lang.org/overviews/scala-book/for-loops.html][https_docs.scala-lang.org_overviews_scala-book_for-loops.html]

![在这里插入图片描述][ea330bdce57a4de5b27c8e5f44cb31c7.png_pic_center]

在 Scala 中，`for` 循环是一种常用的迭代控制结构，它允许你对集合、数组或者范围进行迭代操作。`for` 循环的语法有多种形式，以下是对 Scala 中 `for` 循环的详细解释：

1.  迭代集合：  
    你可以使用 `for` 循环来迭代一个集合（List、Array、Set 等）。以下是迭代集合的基本语法：
    
        val collection = Seq(1, 2, 3, 4, 5)
        for (element <- collection) {
              
          // 循环体中的代码，element 是集合中的每个元素
        }
    
    在上述代码中，`collection` 是一个包含整数的集合。`for` 循环会遍历集合中的每个元素，将当前元素赋值给 `element` 变量，然后执行循环体中的代码。
2.  迭代范围：  
    你可以使用 `for` 循环来迭代一个范围。范围可以由 `to` 或 `until` 运算符创建。以下是迭代范围的基本语法：
    
        for (i <- start to end) {
              
          // 循环体中的代码，i 是范围内的每个值
        }
    
    或者使用半开区间：【左闭右开】
    
        for (i <- start until end) {
              
          // 循环体中的代码，i 是范围内的每个值
        }
    
    在上述代码中，`start` 和 `end` 是范围的起始和结束值（包括或不包括结束值），`i` 是范围内的每个值。
3.  带条件的迭代：  
    你可以在 `for` 循环中添加条件来过滤迭代的元素。以下是带条件的迭代的基本语法：
    
        for (element <- collection if condition) {
              
          // 循环体中的代码，element 是满足条件的集合中的每个元素
        }
    
    在上述代码中，`condition` 是一个条件表达式，只有满足该条件的元素才会被迭代。
4.  嵌套迭代：  
    你可以在 `for` 循环中嵌套另一个 `for` 循环来实现多层迭代。以下是嵌套迭代的基本语法：
    
        for (outer <- collection1) {
              
          for (inner <- collection2) {
              
            // 循环体中的代码，outer 是 collection1 的每个元素，inner 是 collection2 的每个元素
          }
        }
    
    在上述代码中，外部的 `for` 循环会先迭代 `collection1` 中的每个元素，然后内部的 `for` 循环会针对每个

外部元素迭代 `collection2` 中的每个元素。

除了以上基本用法，Scala 的 `for` 循环还支持更多高级特性，如生成器、模式匹配、yield 表达式等。这些特性可以进一步增强 `for` 循环的灵活性和表达能力。

总结起来，Scala 的 `for` 循环提供了一种简洁、直观的方式来迭代集合、数组或者范围，并且可以通过条件和嵌套等方式灵活地控制迭代过程。

代码演示：

package com.dingjiaxiong.scala.basic
    
    /**
     * for循环 *****
     */
    object ForApp {
        
      def main(args: Array[String]): Unit = {
        
    
        // 循环守卫
        for (i <- 1 to 10 if i != 5) {
        
          //        println(i)
        }
    
        // 99乘法口诀表
    
        //    for(i <- 1 to 9) {
        
        //      for(j <- 1 to i) {
        
        //        print(s"$j * $i = ${i * j}\t")
        //      }
        //      println()
        //    }
    
        //    for(i <-1 to 9; j <- 1 to i) {
        
        //      print(s"$j * $i = ${i * j}\t")
        //      if(i == j) println()
        //    }
    
    
        // for这种写法是没有返回值的
        //    val res = for(i <- 1 to 10) i * i
        //    println(res)
    
        // 循环返回值  使用yield关键字【返回一个集合】
        //    val res = for(i <- 1 to 10) yield i * i
        //    println(res)
    
    
        // ==> upper
        val str = "abcd"
        //    val res = for(s <- str) yield s.toUpper
        //    println(res)
        val res = str.map(x => x.toUpper).mkString("")
        println(res)
      }
    
      def test01(): Unit = {
        
        // to [a,b]
        for (i <- 1 to 10) {
        
          //      println(i)
        }
    
        // 1.to(10)  ==>  1 to 10
        for (i <- 1.to(10)) {
        
          //      println(i)
        }
    
        // until [a,b)  1.until(10) ==> 1 until 10
        for (i <- 1.until(10)) {
        
          //      println(i)
        }
    
        // to的第二个参数是步长
        for (i <- 1.until(10, 2)) {
        
          //      println(i)
        }
    
        for (i <- 1 to 10 by 2) {
        
          //      println(i)
        }
    
        for (i <- 1 to 10 reverse) {
        
          //      println(i)
        }
    
        for (i <- 10 to 1 by -1) {
        
          println(i)
        }
      }
    
    }

![在这里插入图片描述][f87ef2fadee74da9805c351ebd37d5aa.png_pic_center]

[90898376d6c74ba19b1f910010efbda4.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/bc5fbcfce5dd4dec8574ae7a595edf69.png
[431ca3651106485b87443c05dea73d31.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/afceb7239ef6400192b659077d8df7ef.png
[https_docs.scala-lang.org_overviews_scala-book_for-loops.html]: https://docs.scala-lang.org/overviews/scala-book/for-loops.html
[ea330bdce57a4de5b27c8e5f44cb31c7.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/2d0679acbd60464991403f2e4024427e.png
[f87ef2fadee74da9805c351ebd37d5aa.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/742a14348f3b45bb9e51d8d2f90cb375.png