【Scala流程控制】09、循环结构

经常地，我们需要遍历集合中的元素，或者对集合中的每个元素进行操作，或者从现有集合创建一个新集合，这就需要用到循环结构。Scala拥有与Java和C++相同的while和do-while以及for循环。

一、while循环

在 Scala 中，while 是一种常用的循环结构，用于反复执行一段代码块，直到给定的条件不再满足。while 循环在条件为真时执行循环体中的代码，直到条件为假为止。

while 循环的基本语法如下：

while (condition) {
    
    
  // 循环体代码
}

其中：

• condition 是一个布尔表达式，用于控制循环是否执行。只要 condition 为真，循环体中的代码会一直执行；一旦 condition 为假，循环终止，程序继续执行后续的代码。

示例：

var count = 0

while (count < 5) {
    
    
  println(s"Current count: $count")
  count += 1
}

在上述示例中，我们定义了一个变量 count 并初始化为 0。然后，使用 while 循环来判断 count 是否小于 5，只要满足这个条件，循环体中的代码会一直执行。在每次循环迭代中，我们打印当前的 count 值，并将 count 递增。当 count 的值达到 5 时，while 循环条件不再满足，循环终止。

输出结果为：

Current count: 0
Current count: 1
Current count: 2
Current count: 3
Current count: 4

需要注意的是，使用 while 循环时，需要确保循环条件最终会为假，否则可能导致无限循环。在函数式编程中，推荐尽量使用 for 推导式或高阶函数等函数式风格的循环，以提高代码的可读性和安全性。

二、do while循环

我要为之前的回答做出更正。实际上，Scala 中是有 do-while 循环的语法的。

do-while 循环语法如下：

scalaCopy codedo {
  // 循环体
} while (condition)

在 do-while 循环中，首先会执行一次循环体，然后检查 while 后面的条件，如果条件为真，则继续执行循环体，直到条件为假时才停止循环。

示例使用 do-while 循环：

var x = 0

do {
  println(s"Current x: $x")
  x += 1
} while (x < 5)

输出结果为：

Current x: 0
Current x: 1
Current x: 2
Current x: 3
Current x: 4

需要注意

在上述示例中，do-while 循环会输出从 0 到 4 的数字，因为 x 会在每次循环体中自增，直到 x 不再小于 5 为止。

所以，do-while 循环是 Scala 中的一种循环结构，您可以使用它来实现与传统编程语言中相同的循环行为。

三、for循环

在 Scala 中，for 循环是一种用于遍历集合（例如列表、数组、范围等）的控制结构。Scala 的 for 循环非常灵活，可以以多种方式来使用，包括对集合进行遍历、过滤、映射等操作。

for 循环的基本语法如下：

scalaCopy codefor (pattern <- collection) {
  // 循环体
}

其中：

• collection 是一个可遍历（Iterable）的集合，例如列表（List）、数组（Array）、范围（Range）等。
• pattern 是一个模式匹配，用于从 collection 中提取元素并绑定到变量。
• 循环体是在每次迭代中执行的代码块，对每个元素进行操作。

示例使用 for 循环遍历列表：

val myList = List(1, 2, 3, 4, 5)

for (x <- myList) {
  println(x)
}

上述代码会输出列表 myList 中的每个元素，即：

1
2
3
4
5

四、for循环配合if进行条件筛选

还可以在 Scala 中使用 for 循环配合 if 条件进行条件筛选，以过滤集合中的元素。

for 循环和 if 条件的组合语法如下：

for (pattern <- collection if condition) {
    
    
  // 循环体
}

在上述语法中，collection 是一个可遍历（Iterable）的集合，pattern 是用于模式匹配的变量，condition 是一个布尔表达式，用于过滤满足条件的元素。

示例使用 for 循环和 if 条件进行条件筛选：

val myList = List(1, 2, 3, 4, 5)

for (x <- myList if x % 2 == 0) {
    
    
  println(x)
}

上述代码会输出列表 myList 中的偶数元素，即：

2
4

在上述示例中，我们使用 for 循环遍历列表 myList 中的每个元素，然后使用 if 条件进行筛选，只输出满足条件的偶数元素。

通过将 for 循环和 if 条件结合使用，您可以方便地对集合进行条件筛选，以得到满足特定条件的元素。这是 Scala 中常用的一种集合处理方式，尤其在数据处理和过滤的场景中非常有用。

五、多重for循环

此外Scala中还可以使用多重 for 循环来进行嵌套遍历。多重 for 循环用于在多个集合上进行嵌套迭代，对集合的所有组合进行操作。

多重 for 循环的语法如下：

scalaCopy codefor (pattern1 <- collection1; pattern2 <- collection2; ...; patternN <- collectionN) {
  // 循环体
}

其中：

• collection1, collection2, …, collectionN 是多个可遍历（Iterable）的集合，例如列表（List）、数组（Array）、范围（Range）等。
• pattern1, pattern2, …, patternN 是模式匹配，用于从对应的集合中提取元素并绑定到变量。
• 循环体是在每次迭代中执行的代码块，对每个元素进行操作。

示例使用多重 for 循环遍历两个列表的所有组合：

scalaCopy codeval list1 = List(1, 2, 3)
val list2 = List("A", "B")

for (x <- list1; y <- list2) {
  println(s"$x - $y")
}

上述代码会输出列表 list1 和 list2 中元素的所有组合，即：

cssCopy code1 - A
1 - B
2 - A
2 - B
3 - A
3 - B

在上述示例中，我们使用两个 for 循环嵌套，遍历列表 list1 和 list2 中的所有组合，并输出每个组合的元素。

多重 for 循环可以用于处理多个集合的组合情况，它提供了一种简洁的方式来处理多重迭代场景。但需要注意的是，多重 for 循环可能会导致嵌套层级过深，使得代码难以阅读和维护。在使用多重 for 循环时，请确保代码结构清晰，避免过度复杂的嵌套。

六、to 和 until

在 Scala 中，to 和 until 是用于创建范围（Range）的方法。

1. to 方法：to 方法用于创建一个包含开始值和结束值的闭区间范围。范围包含开始值和结束值本身。

scalaCopy codeval range1 = 1 to 5 // 创建一个包含1到5的闭区间范围
println(range1)    // 输出：Range 1 to 5

在上述示例中，1 to 5 创建了一个闭区间范围，该范围包含了从 1 到 5 的所有整数。

1. until 方法：until 方法用于创建一个包含开始值但不包含结束值的半开区间范围。范围包含开始值但不包含结束值。

scalaCopy codeval range2 = 1 until 5 // 创建一个包含1到4的半开区间范围
println(range2)       // 输出：Range 1 until 5

在上述示例中，1 until 5 创建了一个半开区间范围，该范围包含了从 1 到 4 的所有整数，但不包含 5。

范围是一个非常有用的数据结构，它表示了一系列连续的整数。您可以在范围上使用 for 循环来遍历其中的元素，也可以通过其他方法来对范围进行操作和转换。范围在处理数值范围和循环迭代时非常实用。

在 Scala 的 for 循环中，to 和 until 可以用于创建范围（Range），然后在循环中使用这些范围来遍历整数序列。下面是使用 to 和 until 的两个例子：

1. 使用 to 创建闭区间范围，在 for 循环中遍历：

// 使用 to 创建闭区间范围，遍历 1 到 5 的整数
for (i <- 1 to 5) {
    
    
  println(i)
}

输出：

1
2
3
4
5

在这个例子中，1 to 5 创建一个闭区间范围，包含了从 1 到 5 的整数。然后在 for 循环中使用这个范围，遍历范围内的所有整数并输出。

2. 使用 until 创建半开区间范围，在 for 循环中遍历：

// 使用 until 创建半开区间范围，遍历 1 到 5 的整数（不包括 5）
for (i <- 1 until 5) {
    
    
  println(i)
}

输出：

1
2
3
4

在这个例子中，1 until 5 创建一个半开区间范围，包含了从 1 到 4 的整数，但不包括 5。然后在 for 循环中使用这个范围，遍历范围内的所有整数并输出。

总结：在 for 循环中，to 方法用于创建闭区间范围（包含开始值和结束值），until 方法用于创建半开区间范围（包含开始值但不包含结束值）。通过使用这些范围，您可以方便地遍历整数序列并执行相应的操作。

七、for循环遍历集合

在 Scala 中，for 循环是一种常用的遍历集合的方式。通过 for 循环，您可以遍历列表（List）、数组（Array）、范围（Range）等可遍历（Iterable）的集合，对集合中的每个元素执行特定的操作。

for 循环的基本语法如下：

for (pattern <- collection) {
    
    
  // 循环体
}

其中：

• collection 是一个可遍历（Iterable）的集合，例如列表（List）、数组（Array）、范围（Range）等。
• pattern 是一个模式匹配，用于从 collection 中提取元素并绑定到变量。
• 循环体是在每次迭代中执行的代码块，对每个元素进行操作。

示例使用 for 循环遍历列表：

val myList = List(1, 2, 3, 4, 5)

for (x <- myList) {
    
    
  println(x)
}

上述代码会输出列表 myList 中的每个元素，即：

1
2
3
4
5

除了列表，您也可以使用 for 循环遍历其他类型的集合，例如数组：

val myArray = Array(10, 20, 30, 40, 50)

for (x <- myArray) {
    
    
  println(x)
}

上述代码会输出数组 myArray 中的每个元素，即：

10
20
30
40
50

八、for循环配合yield

在 Scala 中，for 循环配合 yield 关键字可以创建一个称为 “for 推导式”（for-comprehension）的特殊结构。使用 for 推导式，您可以在循环中应用条件和转换，然后生成一个新的集合。

for 推导式的基本语法如下：

val result = for (pattern <- collection if condition) yield expression

其中：

• collection 是一个可遍历（Iterable）的集合，例如列表（List）、数组（Array）、范围（Range）等。
• pattern 是一个模式匹配，用于从 collection 中提取元素并绑定到变量。
• condition 是一个布尔表达式，用于对元素进行条件过滤。
• expression 是一个表达式，根据 pattern 中绑定的变量生成一个新的值。

for 推导式会遍历 collection 中的元素，对每个元素应用 condition 进行过滤，然后根据 expression 生成一个新的集合，将满足条件的元素加入新集合。

示例使用 for 循环配合 yield 进行条件筛选和映射：

val myList = List(1, 2, 3, 4, 5)

val squaredNumbers = for (x <- myList if x % 2 == 0) yield x * x

println(squaredNumbers) // 输出：List(4, 16)

在上述示例中，我们使用 for 推导式遍历列表 myList 中的元素，然后对每个元素应用条件 if x % 2 == 0 进行筛选。满足条件的偶数元素会被平方后生成一个新的列表 squaredNumbers。

通过 for 推导式，您可以方便地在循环中应用条件和映射，从而生成一个新的集合。这是 Scala 中非常常用且强大的集合处理方式之一。