Scala基础语法入门（三）Scala中的各种运算符

🙆‍♂️🙆‍♂️ 写在前面

​🏠​ 个人主页：csdn春和
📚 推荐专栏：更多专栏尽在主页！
 JavaWeb专栏（从入门到实战超详细！！！）
 SSM专栏 （更新中…）
​📖​ 本期文章：Scala基础语法入门（三）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)

}

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

}

---

📢 字符串的比较：

“==” 在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
    }
}

📙 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方法

  }
}

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 表示为空

  }
}

4、赋值运算符

赋值运算符就是将某个运算后的值，赋给指定的变量。

注意：Scala 中没有++、--操作符，可以通过+=、-=来实现同样的效果；

++运算有歧义，容易理解出现错误，所以scala中没有这样的语法，所以采用 +=的方式来代替。

object Scala01_Operator5 {

  def main(args: Array[String]): Unit = {
    // TODO 赋值运算符
    var r1 = 10

    r1 += 1 // 没有++
    r1 -= 2 // 没有--

    println(r1)

  }
}

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

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) // 当参数只有一个或者没有时（）可以省略

  }
}

所以scala更加的是面向对象