Scala学习之运算符

算术运算符

基本语法

1. 对于除号"/"，他的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
2. 对于一个数取模a%b，和Java的取模规则一样

package com.gm.chapter02

/**
  * @Author: Gm
  * @Date: 2021/6/17 9:33
  */

object TestOperator {
  def main(args: Array[String]): Unit = {
    //对于除号“/”，他的整数除和小数除是有区别的：整数除之间的做除法时，只保留整数部分而舍弃小数部分。
    var r1: Int = 10 / 3 //3
    println("r1 = " + r1)

    var r2: Double = 10 / 3 //3.0
    println("r2 = " + r2)

    var r3: Double = 10.0 / 3 //3.33333333
    println("r3 = " + r3)
    println("r3 = " +r3.formatted("%.2f")) //含义：保留小数点2位，使用四舍五入

    //对一个数取模a%b,和Java的取模规则一样
    var r4 = 10 % 3 // 1
    println("r4 = " + r4)
  }
}

关系运算符

基本语法

package com.gm.chapter02

/**
  * @Author: Gm
  * @Date: 2021/6/17 9:41
  */

object TestRelationOperator {
  def main(args: Array[String]): Unit = {
    // 测试：>、>=、<=、<、==、!=
    var a: Int = 2
    var b: Int = 1

    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 static void main(String[] args) {
    
    String s1 = "abc";
    String s2 = new String("abc");

    System.out.println(s1 == s2);

    System.out.println(s1.equals(s2));
}
输出结果：
false
true

• Scala：==更加类似于Java中的equals，参照jd工具

package com.gm.chapter02

/**
  * @Author: Gm
  * @Date: 2021/6/17 9:42
  */

object TestEquals {
  def main(args: Array[String]): Unit = {
    //Java中：==表示两个变量本身的值，即两个对象在内存中的首地址
    //        equals比较字符串中所包含的内容是否相同


    //Scala中：==相当于调用equals方法；要比较地址值需要用eq()方法

    val s1 = "abc"

    val s2 = new String("abc")

    println(s1 == s2)       //true
    println(s1.equals(s2))  //true
    println(s1.eq(s2))      //false
  }
}

逻辑运算符

基本语法

• 用于连接多个条件（一半来讲就是关系表达式），最终的结果也是一个Boolean值。
  

package com.gm.chapter02

/**
  * @Author: Gm
  * @Date: 2021/6/17 9:47
  */

object TestLogic {
  def main(args: Array[String]): Unit = {
    // 测试：&&、||、!
    var a = true
    var b = false

    println("a&&b=" + (a && b))     // a&&b=false
    println("a||b=" + (a || b))     // a||b=true
    println("!(a&&b)=" + (!(a && b))) // !(a&&b)=true
  }

  def isNotEmpty(s: String): Boolean = {
    //如果按位。s为了空，会发生空指针
    s != null && !"".equals(s.trim)
  }
}

赋值运算符

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

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

package com.gm.chapter02

/**
  * @Author: Gm
  * @Date: 2021/6/17 9:53
  */

object TestAssignment {
  def main(args: Array[String]): Unit = {
    var r1 = 10

    r1 += 1 // 没有++
    println(r1) //11
    r1 -= 2 // 没有--
    println(r1) //9
  }
}

位运算符

基本语法
下表中变量a为60，b为13。

package com.gm.chapter02

/**
  * @Author: Gm
  * @Date: 2021/6/17 9:55
  */

object TestPosition {
  def main(args: Array[String]): Unit = {
    // 测试：1000 << 1 =>10000
    var n1 :Int =8

    n1 = n1 << 1
    println(n1)
  }
}

Scala运算符本质

其实Scala中其实是没有运算符的，所有的运算符都是方法

• 当调用对象的方法时，点. 可以省略
• 如果函数参数只有一个，或者没有参数，()可以省略

object TestOpt {
    def main(args: Array[String]): Unit = {

        // 标准的加法运算
        val i:Int = 1.+(1)

        // （1）当调用对象的方法时，.可以省略
        val j:Int = 1 + (1)

        // （2）如果函数参数只有一个，或者没有参数，()可以省略
        val k:Int = 1 + 1
        
        println(1.toString())
        println(1 toString())
        println(1 toString)
    }
}