文章目录
scala判断与循环
判断
if else
结构为if(条件){真区间执行内容}else{假区间内容}，当满足条件程序进入真区间执行内容，不满足则进入假区间
object TestEx{
def main(args:Array[String]):Unit={
var ldsx2 = 9
if (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 = 9
if (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 = 9
if (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 = 20
while(ldsx2<=30)
{
println(ldsx2+" :__info")
ldsx2+=1
}
}
}
do while 循环
结构：do {} while(条件)，必会先执行一次do中内容，然后while判断是否满足满足开始循环。
object TestEx{
def main(args:Array[String]):Unit={
var ldsx2 = 15
do {
ldsx2+=1
println("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 <- numList
if 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 关键字提供了一种简洁、声明式和函数式的方式来生成新的集合，支持过滤、转换、模式匹配和变量定义。