装饰设计资质乙级_大连开发区网站设计公司_邯郸网站seo_广东seo网站优化公司

scala判断与循环

判断

if else

结构为if(条件){真区间执行内容}else{假区间内容}，当满足条件程序进入真区间执行内容，不满足则进入假区间

object TestEx{def main(args:Array[String]):Unit={var ldsx2 = 9if (ldsx2>=10){println(ldsx2+">=10")}else{println(ldsx2+"<10")}
}

else if 分支判断

结构为if(条件){满足区间内容}else if(条件){满足区间内容}else{区域区间}，多分支判断，进入最先符合条件的分支，只判断一次。

object TestEx{def main(args:Array[String]):Unit={var ldsx2 = 9if (ldsx2>=10){println(ldsx2+">=10")}else if(ldsx2>=5){println(ldsx2+">=5")}else if (ldsx2>=3){println(ldsx2+">=3")}else{println("else ")}
}

判断语句嵌套

在判断语句中继续使用判断语句

结构为if(条件){ if(条件){内容}else{内容} }else if(条件){满足区间内容}else{区域区间}

object TestEx{def main(args:Array[String]):Unit={var ldsx2 = 9if (ldsx2>=10){if (ldsx2>=20){println("进入嵌套境真区间")}else{println("进入嵌套境假区间")}println(ldsx2+">=10")}else if(ldsx2>=5){println(ldsx2+">=5")}else if (ldsx2>=3){println(ldsx2+">=3")}else{println("else ")}
}

循环

scala 中没有break，continue控制循环的方法，只能自己实现，continue就用空代替好了。

while循环

while(条件){内容}

object TestEx{def main(args:Array[String]):Unit={var ldsx2 = 20while(ldsx2<=30){println(ldsx2+" :__info")ldsx2+=1}}
}

do while 循环

结构：do {} while(条件)，必会先执行一次do中内容，然后while判断是否满足满足开始循环。

object TestEx{def main(args:Array[String]):Unit={var ldsx2 = 15do {ldsx2+=1println("do ldsx2:"+ldsx2)} while (ldsx2<=19)println(ldsx2)}
}    

for循环

在 Scala 中，<- 符号用于 for 表达式和 for 循环中，它被称为生成器（generator）。i <- 1 to 5 是一个生成器，它表示 i 将依次取值 1、2、3、4、5，

遍历range

结构：a <- i to/until j，循环可以用于遍历集合和范围。to 和 until 关键字用于生成范围（Range）

to 与 until

to 包含j，打印到10

for (a <- 1 to 10) {println("Value of a: " + a);
}

until 不包含j，打印到9

for (a <- 1 to 10) {println("Value of a: " + a);
}

遍历集合

a <- list,换成要遍历的集合即可

val list1 = List(1,2,3,4)
for ( a <-list1){println("data"+a)
}

遍历字符

val str1 = "Hello"
for (a <- str1) {println(a)
}
//如果你想要遍历字符串的索引和字符，你可以使用 `zipWithIndex` 方法，临时变量需要解包分别接受字符，索引
val str1 = "Hello"
println(str1.zipWithIndex)
for ((a,b) <- str1.zipWithIndex) {println(a,b)
}//Vector((H,0), (e,1), (l,2), (l,3), (o,4))
//(H,0)
//(e,1)
//(l,2)
//(l,3)
//(o,4)

循环嵌套

在 Scala 中，双重 for 循环和嵌套的 for 循环在功能上是等价的，它们都用于遍历两个或多个集合的所有组合。然而，在语法和可读性方面，它们有一些不同。

内部 for 循环（也可以多个）

双重 for 循环使用分号（;）分隔两个生成器，它们在同一个 for 表达式中。这种方式在遍历两个集合的所有组合时非常简洁。

val list1 = List(1, 2, 3)
val list2 = List('a', 'b', 'c')for (i <- list1; j <- list2) {println(s"$i, $j")
}

三循环

val list1 = List(1, 2, 3)  for (a <- list1;b<-1 to 5;c <-"abc"){println(a,b,c)}

嵌套的 for 循环

嵌套的 for 循环是在一个 for 循环内部再包含一个或多个 for 循环。这种方式在遍历多个集合时提供了更多的灵活性，但可能在某些情况下显得更加冗长。

for (i <- list1) {for (j <- list2) {println(s"$i, $j")}
}

比较

• 简洁性：双重 for 循环通常比嵌套的 for 循环更简洁，特别是当遍历两个集合时。
• 可读性：双重 for 循环的可读性可能更好，因为它们将所有生成器放在一个表达式中，使代码更加紧凑。
• 灵活性：嵌套的 for 循环提供了更多的灵活性，因为你可以添加额外的逻辑和条件，例如在内部循环中使用守卫或添加其他控制结构。

选择使用哪种方式

• 如果你只需要遍历两个集合的所有组合，双重 for 循环可能是更好的选择。
• 如果你需要在循环中添加额外的逻辑或条件，或者遍历多个集合，嵌套的 for 循环可能更合适。

if 守卫

if守卫支持for不支持while

筛选条件过滤多条件使用逗号分隔；只能使用if 不能使用if else，做一些简单的判断，复杂的还是要在内层中结合if else，

for (a <- 1 to 10;if a !=9;if a %2 != 0) {println("filter: " + a);
}

循环内变量

square可在循环内直接使用

for (number <- numbers1; number2 <- List(6,7);square = number * number2) {println(s"Number: $number, Number2: $number2,Square: $square")
}Number: 1, Number2: 6,Square: 6
Number: 1, Number2: 7,Square: 7
Number: 2, Number2: 6,Square: 12
Number: 2, Number2: 7,Square: 14
Number: 3, Number2: 6,Square: 18
Number: 3, Number2: 7,Square: 21
Number: 4, Number2: 6,Square: 24
Number: 4, Number2: 7,Square: 28
Number: 5, Number2: 6,Square: 30
Number: 5, Number2: 7,Square: 35

注意

• for 循环中的循环变量是一个临时变量，它的作用域仅限于 for 循环内部。
• 用 var 关键字声明的变量是一个可变的变量，它的作用域取决于它在代码中的位置。

a <- list,换成要遍历的集合即可，for循环使用的a是临时变量与var 声明的a不同

val list1 = List(1,2,3,4)
var a = 0
for ( a <-list1){println("data"+a)
}

yield 迭代返回

可以把迭代返回当成变量接收

object Test {def main(args: Array[String]) {var a = 0;val numList = List(1,2,3,4,5,6,7,8,9,10);// for 循环var retVal = for{ a <- numListif a != 3; if a < 8} yield a// 输出返回值for( a <- retVal){println( "Value of a: " + a );}}
}val numbers1 = List(1, 2, 3)
val numbers2 = List(4, 5, 6)val productPairs = for (a <- numbers1; b <- numbers2) yield (a, b)println(productPairs)  
// 输出: Vector((1,4), (1,5), (1,6), (2,4), (2,5), (2,6), (3,4), (3,5), (3,6))

在 Scala 中，yield 关键字与 for 表达式结合使用，用于生成一个集合。使用 yield 的主要好处包括：

1. 简洁的集合生成

yield 允许你以一种简洁和声明性的方式生成新的集合。你不需要显式地构造集合，只需描述如何从现有集合生成新集合。

val numbers = List(1, 2, 3, 4, 5)
val doubled = for (n <- numbers) yield n * 2

2. 支持过滤和转换

yield 可以与守卫（if 条件）结合使用，以便过滤元素。你还可以在 yield 表达式中进行转换操作。

val numbers = List(1, 2, 3, 4, 5)
val evenDoubled = for (n <- numbers if n % 2 == 0) yield n * 2

3. 支持多个生成器

yield 可以与多个生成器一起使用，以生成笛卡尔积或其他组合。

val letters = List('a', 'b', 'c')
val numbers = List(1, 2, 3)
val combinations = for (l <- letters; n <- numbers) yield (l, n)

4. 支持模式匹配

在 yield 表达式中，你可以使用模式匹配来解构元素。

val pairs = List((1, "one"), (2, "two"), (3, "three"))
val firstElements = for ((first, _) <- pairs) yield first

5. 支持变量定义

你可以在 for 表达式中定义变量，并在 yield 表达式中使用它们。

val numbers = List(1, 2, 3, 4, 5)
val result = for (n <- numbers; square = n * n) yield square

6. 函数式编程风格

yield 符合函数式编程范式，因为它不修改现有集合，而是生成一个新的集合。这有助于编写更干净、更易于维护的代码。

7. 支持惰性求值

在某些情况下，for 表达式可以惰性地求值，这意味着集合元素只在需要时才被计算。这有助于提高性能，特别是在处理大型集合时。

总之，yield 关键字提供了一种简洁、声明式和函数式的方式来生成新的集合，支持过滤、转换、模式匹配和变量定义。