🙆♂️🙆♂️ 写在前面
🏠 个人主页：
📚 推荐专栏：软件系统定制开发更多专栏尽在主页！
📖 本期文章：软件系统定制开发基础语法入门（三）Scala软件系统定制开发中的各种运算符
软件系统定制开发如果对您有帮助还请三连支持，定会一 一回访！🙋🏻♂️
本文目录
Scala中的
1、软件系统定制开发算数运算符
Scala 软件系统定制开发运算符的使用和 Java 运算符的使用基本相同
def main(args: Array[String]): Unit = { // 1、算数运算符 // 整数之间的除法运算只保留整数部分 var r1: Int = 10 / 3 // 3 println("r1=" + r1) var r2: Double = 10 / 3 // 3.0 println("r2=" + r2) // 只要除数和被除数有一个是Double类型那么结果就是Double类型的 var r3: Double = 10.0 / 3 // 3.3333 println("r3=" + r3) println("r3=" + r3.formatted("%.2f")) // 含义：保留小数点 2位，使用四舍五入 //（2）对一个数取模 a%b，和 Java 的取模规则一样。 var r4 = 10 % 3 // 1 余1 println("r4=" + r4)}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
2、比较运算符
def main(args: Array[String]): Unit = { // 比较运算符 var a: Int = 10 var b: Int = 5 println(a > b) // true println(a >= b) // true println(a <= b) // false println(a < b) // false println("a==b " + (a == b)) // false println(a != b) // true}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
📢 字符串的比较：
“==” 在Java和Scala中的区别
📕 Java中：
== 比较两个变量本身的值，即两个对象在内存中的首地址；
equals 比较字符串中所包含的内容是否相同
public class JavaTest3 { public static void main(String[] args) { String str1 = new String("123"); String str2 = new String("123"); // 在java中 == 符号比较的是内存地址 System.out.println(str1 == str2); // false // 想要比较两个对象的内容是否相等需要使用equals System.out.println(str1.equals(str2)); // true }}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
📙 Scala中：==更加类似于 Java 中的 equals，参照 jd 工具
object Scala01_Operator3 { def main(args: Array[String]): Unit = { // 字符串比较 val s1: String = new String("123") val s2: String = new String("123") // 在scala中 == 就相当于java中的equals 判断的是内容是否相等 println(s1 == s2) // true // 在Scala中 eq() 比较的两个对象的内存地址 println(s1.eq(s2)) // false println(s1.equals(s2)) // true equals保留的是java中的equals方法 }}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
3、
用于连接多个条件（一般来讲就是关系表达式），最终的结果也是一个 Boolean 值。
逻辑运算符存在特性，有短路与 短路或
短路与： 只要第一个为false 则就位为false 后面的不再判断
短路或：只要有一个为true就位true 后面也不用判断
代码示例：
def main(args: Array[String]): Unit = { // TODO 逻辑运算符 def test(num:Int): Int ={ print("test方法被调用！") return num } // 扩展避免逻辑与空指针异常 def isNotEmpty(s:String):Boolean = { //如果按位与，s 为空，会发生空指针 return s!=null && !"".equals(s.trim()); // 去掉空格 } val num = 2 println((4<5) && test(num)>0) // 前面为true 后面为true 正常输出 test方法被调用！true println((4>5) && test(num)>0) // 前面为false 后面为true 短路与 后面的判断不再进行 只输出false println((4>5) || test(num)>0) // 前面为false 后面为true 正常输出 test方法被调用！true println((4<5) || test(num)>0) // 前面为true 后面为true 短路或 不再进行后面的判断 输出 true println("----------------------------------------------------------") val s1 = "hello" val s2 = " " println(isNotEmpty(s1)) // true 表示不为空 println(isNotEmpty(s2)) // false 表示为空 }}- 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
4、
赋值运算符就是将某个运算后的值，赋给指定的变量。
注意：Scala 中没有++、--操作符，可以通过+=、-=来实现同样的效果；
++运算有歧义，容易理解出现错误，所以scala中没有这样的语法，所以采用 +=的方式来代替。
object Scala01_Operator5 { def main(args: Array[String]): Unit = { // TODO 赋值运算符 var r1 = 10 r1 += 1 // 没有++ r1 -= 2 // 没有-- println(r1) }}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
5、符
下表中变量 a 为 60，b 为 13
位运算符运算分析： 我们假设 val a:Byte = 60 val b : Byte = 13 Byte只占一个字节 a 原码：0011 1100 反码：0011 1100 补码：0011 1100 b 原码：0000 1101 反码：0000 1101 补码：0000 1101 在底层采用的是补码存储，所以我们来看看位运算 & 按位与 两位全为1，结果为1，否则为0 a: 0011 1100 b: 0000 1101 a&b: 0000 1100 --> 转为十进制 12 ； a&b = 12 | 按位或 有一个为1，结果为1，否则为0 a: 0011 1100 b: 0000 1101 a|b: 0011 1101 --> 转为十进制 61 ； a|b = 61 ~ 按位取反 0 --> 1 ; 1 --> 0 a: 0011 1100 ~a: 1100 0011 这是一个有符号的负数的补码，所以我们需要计算出这个数的原码 // 规则 负数的原码符号位不变其余为取反得到反码 反码+1得到该负数的补码形式 反码 = 补码 - 1 ； 1100 0011 - 1 = 1100 0010 原码： 1011 1101 --> 转为十进制 -61 ~a = -61 ^ 按位异或 不一样的为1 一样的为0 即 两个都是1或者·两个都是0 为0；一个1一个0 则为1 a: 0011 1100 b: 0000 1101 a^b: 0011 0001 --> 转为十进制 49 ； a^b = 49- 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运算符的本质
在 Scala 中其实是没有运算符的，所有运算符都是方法。
1）当调用对象的方法时，点.可以省略
2）如果函数参数只有一个，或者没有参数，()可以省略
object Scala01_Operator6 { def main(args: Array[String]): Unit = { // TODO Scala中运算符的本质 val num1:Int = 10 val num2:Int = 20 // 运算符的本质是一个方法 println(num1.+(num2)) println(num1+(num2)) // 点可以省略 println(num1+num2) // 当参数只有一个或者没有时（）可以省略 }}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
所以scala更加的是面向对象