文章目录
第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)
}
}
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)
}
}
第4章 流程控制
Scala程序代码和所有编程语言代码一样，都会有特定的执行流程顺序，默认情况下是顺序执行，上一条逻辑执行完成后才会执行下一条逻辑，执行期间也可以根据某些条件执行不同的分支逻辑代码。
4.1 分支控制
让程序有选择的的执行，分支控制有三种：单分支、双分支、多分支
4.1.1 单分支
IF…ELSE 语句是通过一条或多条语句的执行结果（true或者false）来决定执行的代码块
语法：
if(布尔表达式) {
// 如果布尔表达式为 true 则执行该语句块
}
如果布尔表达式为 true 则执行大括号内的语句块，否则跳过大括号内的语句块，执行大括号之后的语句块。
object ScalaBranch {
def main(args: Array[String]): Unit = {
val b = true
if ( b ) {
println("true")
}
}
}
4.1.2 双分支
语法：
if(布尔表达式) {
// 如果布尔表达式为 true 则执行该语句块
} else {
// 如果布尔表达式为 false 则执行该语句块
}
如果布尔表达式为 true 则执行接着的大括号内的语句块，否则执行else后的大括号内的语句块。
object ScalaBranch {
def main(args: Array[String]): Unit = {
val b = true
if ( b ) {
println("true")
} else {
println("false")
}
}
}
4.1.3 多分支
语法：
if(布尔表达式1) {
// 如果布尔表达式1为 true，则执行该语句块
} else if ( 布尔表达式2 ) {
// 如果布尔表达式2为 true，则执行该语句块
}...
} else {
// 上面条件都不满足的场合，则执行该语句块
}
关于双分支、多分支具体代码如下：
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("老年")
}
}
}
实际上，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)
}
}
4.2 循环控制
有的时候，我们可能需要多次执行同一块代码。一般情况下，语句是按顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。编程语言提供了更为复杂执行路径的多种控制结构。循环语句允许我们多次执行一个语句或语句组
Scala语言提供了以下几种循环类型：
4.2.1 for循环
1)基本语法
for ( 循环变量 <- 数据集 ) {
循环体
}
这里的数据集可以是任意类型的数据集合，如字符串，集合，数组等
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)
}
}
}
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 )
}
}
}
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)
}
}
4.2.2 while循环
1)基本语法
当循环条件表达式返回值为true时，执行循环体代码:
while( 循环条件表达式 ) {
循环体
}
一种特殊的while循环就是，先执行循环体，再判断循环条件是否成立
do {
循环体
} while ( 循环条件表达式 )
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)
}
}
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")
}
}
手把手带你学习Scala(三)-Scala运算符和流程控制到这里就介绍完了，小伙伴们点赞、收藏、评论，一键三连走起呀，下期见~~
最后感谢尚硅谷的资料分享，本文仅用于交流学习，不用于商业性使用
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
