• 手把手带你学习Scala(三)-Scala运算符和流程控制

    文章目录

    第3章 运算符

    Scala运算符的使用和Java运算符的使用基本相同，只有个别细节上不同。

    3.1 算数运算符

    假定变量 A 为 10，B 为 20。
    在这里插入图片描述

    3.2 关系运算符

    假定变量A为10，B为20。
    在这里插入图片描述

    package com.dt.bigdata.scala.chapter03
object Scala01_Oper {
    def main(args: Array[String]): Unit = {
        // TODO 运算符
        val s1 = new String("abc")
        //val s1 : String = null
        val s2 = new String("abc")
        // 马丁想：判断两个对象的内存地址的意义
        // 判断对象是否相等，双等号会更加直观
        // scala语法中双等号就是比较对象的内容,但是和equals不一样。是非空equals操作
        println( s1 == s2 ) // 比较内容和内存，非空判断时候不会报错
        println( s1.equals(s2) ) //非空判断时候会报错，上面==不会报错
        println( s1.eq(s2) ) // eq方法在编译后就是java中的双等号(如果非要比较内存地址的话，Scala中应该这样写)
        val s = "abc" * 2
        println(s)
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    3.3 赋值运算符

    在这里插入图片描述
    思考一个问题：为什么在上面的运算符中没有看到 ++， --？
    ++运算有歧义，容易理解出现错误，所以scala中没有这样的语法，所以采用 +=的方式来代替。

    3.4 逻辑运算符

    假定变量 A 为 1，B 为 0
    在这里插入图片描述

    3.5 位运算符

    如果指定 A = 60; 及 B = 13; 两个变量对应的二进制为
    A = 0011 1100
    B = 0000 1101
    在这里插入图片描述

    3.6 运算符本质

    在Scala中其实是没有运算符的，所有运算符都是方法。
    Scala是完全面向对象的语言，所以数字其实也是对象
    当调用对象的方法时，点.可以省略
    如果函数参数只有一个，或者没有参数，()可以省略

    package com.dt.bigdata.scala.chapter03
import com.dt.bigdata.scala.test.User
object Scala02_Oper {
    def main(args: Array[String]): Unit = {
        // TODO 运算符
        // new User()
        // scala是一个完全面向对象的语言，数字也是对象
        val r = 10.+(10)
        val j = 10 + 10
        val k = "abc".*(2)
        // 马丁想
        // 1. 方法在调用时，可以省略点
        // 2. 方法如果参数只有一个或没有，那么小括号可以省略
        val user = new User()
        println(user toString)
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    第4章 流程控制

    Scala程序代码和所有编程语言代码一样，都会有特定的执行流程顺序，默认情况下是顺序执行，上一条逻辑执行完成后才会执行下一条逻辑，执行期间也可以根据某些条件执行不同的分支逻辑代码。

    4.1 分支控制

    让程序有选择的的执行，分支控制有三种：单分支、双分支、多分支

    4.1.1 单分支

    IF…ELSE 语句是通过一条或多条语句的执行结果（true或者false）来决定执行的代码块

    语法：
if(布尔表达式) {
   // 如果布尔表达式为 true 则执行该语句块
}

    • 1
    • 2
    • 3
    • 4

    如果布尔表达式为 true 则执行大括号内的语句块，否则跳过大括号内的语句块，执行大括号之后的语句块。

    object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val b = true
        if ( b ) {
            println("true")
}
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    4.1.2 双分支

    语法：
if(布尔表达式) {
   // 如果布尔表达式为 true 则执行该语句块
} else {
   // 如果布尔表达式为 false 则执行该语句块
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    如果布尔表达式为 true 则执行接着的大括号内的语句块，否则执行else后的大括号内的语句块。

    object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val b = true
        if ( b ) {
            println("true")
} else {
    println("false")
}
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    4.1.3 多分支

    语法：
if(布尔表达式1) {
   // 如果布尔表达式1为 true，则执行该语句块
} else if ( 布尔表达式2 ) {
   // 如果布尔表达式2为 true，则执行该语句块
}...
} else {
   // 上面条件都不满足的场合，则执行该语句块
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    关于双分支、多分支具体代码如下：

    package com.dt.bigdata.scala.chapter04
object Scala02_Flow_If {
    def main(args: Array[String]): Unit = {
        // TODO 流程
        // 分支判断
        val age = 40
        //双分支
//        if ( age == 30 ) {
//            println("年龄等于30")
//        } else {
//            println("其他")
//        }    
        //多分支
        if ( age < 18 ) {
            println("少年")
        } else if ( age < 36 ) {
            println("青年")
        } else if ( age < 45 ) {
            println("壮年")
        } else if ( age < 55 ) {
            println("中年")
        } else {
            println("老年")
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    实际上，Scala中的表达式都是有返回值的，所以上面的小功能还有其他的实现方式

    package com.dt.bigdata.scala.chapter04
object Scala02_Flow_If_1 {
    def main(args: Array[String]): Unit = {
        // TODO 流程
        val age = 30
      // TODO 表达式的返回结果为：表达中满足条件的最后一行代码的执行结果
        val result = if ( age == 30 ) {
            "zhangsan"
        } else {
            null
        }
        //println(re)
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    4.2 循环控制

    有的时候，我们可能需要多次执行同一块代码。一般情况下，语句是按顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。编程语言提供了更为复杂执行路径的多种控制结构。循环语句允许我们多次执行一个语句或语句组
    Scala语言提供了以下几种循环类型：
    在这里插入图片描述

    4.2.1 for循环

    1)基本语法
    for ( 循环变量 <- 数据集 ) {
    循环体
}

    • 1
    • 2
    • 3

    这里的数据集可以是任意类型的数据集合，如字符串，集合，数组等

    2)循环守卫

    循环时可以增加条件来决定是否继续循环体的执行,这里的判断条件我们称之为循环守卫。

    3)循环步长

    scala的集合也可以设定循环的增长幅度，也就是所谓的步长step

    package com.dt.bigdata.scala.chapter04
object Scala03_Flow_for {
    def main(args: Array[String]): Unit = {
        // TODO for循环
    /*
          Java中显示：
          for ( int i = 0; i < 10; i=i+2 ) {
              sout(i)
          }
          // JDK 1.5之后，Java中才出现增强For循环
          //for ( Object obj : list ) {
          for ( list : Object obj  ) {
              sout(obj)
          }
         */
       // Scala 循环
        //val range = 1.to(5)
        //val range = 1 to(5)   这两个都是范围集合
        // to方法包含结束的数据，但是Range的第二个参数(until)不包含
        //val range = 1 to 5 by 2   //从1到5两个两个增加
        //val range = 1 until 5 by 2 跟 val range = Range(1, 5, 2)是一样的，不包含结束的数据。
//        for ( i : Int <- range ) {
//            println(i)
//        }
//        for ( i <- range ) {
//            println(i)
//        }
        for ( i <- Range(5, 1, -1) ) {
            println(i)
        }
    }
}        

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    4)循环嵌套
    5)引入变量
    package com.dt.bigdata.scala.chapter04
object Scala03_Flow_for_1 {
    def main(args: Array[String]): Unit = {
        // TODO for循环
        // TODO 循环守卫
//        for ( i <- Range(1,5) if i != 3  ) {
//            println("%%%%%%%%%")
//            println("i = " + i )
//        }
//        println("************************************")
        //这种方法比上面方法多一次循环，因此首推上面循环守卫写法。
//        for ( i <- Range(1,5)   ) {
//            println("########")
//            if (i != 3) {
//
//                println("i = " + i )
//            }
//        }

        // TODO 循环嵌套
//        for ( i <- Range(1,3); j <- Range(1,1) ) {
//            println("i = " + i + ",j = " + j )
//        }    //这种方式需要两个条件都成立才能循环，优点是更加简洁
//        println("***********************************")
//        for ( i <- Range(1,3) ) {
//            for ( j <- Range(1,1) ) {
//                println("i = " + i + ",j = " + j )
//            }
//        } //这种方式只需要有一个条件成立就能循环，而且更加清晰

        // TODO 引入变量
        for ( i <- Range(1,5); j = i - 1 ) {
            println("j = " + j )
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    6)循环返回值

    Scala所有的表达式都是有返回值的。但是这里的返回值并不一定都是有值的哟。如果希望for循环表达式的返回值有具体的值，需要使用关键字yield

    package com.dt.bigdata.scala.chapter04
object Scala03_Flow_for_2 {
    def main(args: Array[String]): Unit = {
        // TODO for循环
        // 表达式的返回值
        val result = for ( i <- 1 to 5 ) yield {
            i * 2
        }
        println(result)
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    4.2.2 while循环

    1)基本语法

    当循环条件表达式返回值为true时，执行循环体代码:

    while( 循环条件表达式 ) {
    循环体
}

    • 1
    • 2
    • 3

    一种特殊的while循环就是，先执行循环体，再判断循环条件是否成立

    do {
    循环体
} while ( 循环条件表达式 )

    • 1
    • 2
    • 3
    2)while循环
    3)do…while循环

    while 和 do while代码实例：

    package com.dt.bigdata.scala.chapter04
object Scala04_Flow_while {
    def main(args: Array[String]): Unit = {
        var age = 0
        //最基本的while循环
        while ( age < -1 ) {
            println("*******" + age)
            age += 1
        }
        //这个循环不管条件满足不满足，都至少走一次循环；上面的while循环如果条件不满足，一次循环也不会走。
        do {
            println("######" + age)
            age += 1
        } while (age < -1)
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    4.2.3 循环中断

    Scala是完全面向对象的语言，所以无法使用break，continue关键字这样的方式来中断，或继续循环逻辑，而是采用了函数式编程的方式代替了循环语法中的break和continue。

    package com.dt.bigdata.scala.chapter04
import scala.util.control.Breaks._
object Scala05_Flow_break {
    def main(args: Array[String]): Unit = {
//        for ( i <- 1 to 5 ) {
//            if ( i != 3 ) {
//                // scala中没有continue关键字
//                //continue
//                println(i)
//            }
//
//        }

//        Breaks.breakable {
//            for ( i <- 1 to 5 ) {
//                if ( i == 3 ) {
                 // scala中没有break关键字,采用面向对象的方式来代替
//                    // 采用抛出异常的方式来跳出循环
//                    Breaks.break()
//                }
//                println(i)
//            }
//      }这种方式跟下面方式一样都可以解决break问题，推荐使用下面的方式。
        breakable {
            for ( i <- 1 to 5 ) {
                if ( i == 3 ) {
                    // scala中没有break关键字,采用面向对象的方式来代替
                    // 采用抛出异常的方式来跳出循环
                    break
                }
                println(i)
            }
        }
        println("other")
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    手把手带你学习Scala(三)-Scala运算符和流程控制到这里就介绍完了，小伙伴们点赞、收藏、评论，一键三连走起呀，下期见~~
    最后感谢尚硅谷的资料分享，本文仅用于交流学习，不用于商业性使用

  • 相关阅读:
    竞赛无人机搭积木式编程（四）---2023年TI电赛G题空地协同智能消防系统（无人机部分）
    【JavaSE】类和对象
    VLAN 协议知识
    对文件的 SQL 式运算
    企业可以自己建立大数据平台吗？有哪些好处？
    Unity的IPostprocessBuild：深入解析与实用案例
    【打印机配置】斑马打印机配置步骤
    AI机器视觉多场景应用迸发检测活力，引领食品及包装行业新发展
    【C++11】lambda匿名函数和包装器
    思科网络中如何配置标准ACL协议
  • 原文地址：https://blog.csdn.net/aikeaidecxy/article/details/126685988