运算符

· 算术运算符：只能用来做加、减、乘、除等算术运算。

· 关系运算符：用来对数值进行比较，比如>、<=、>=等。

· 逻辑运算符：包含逻辑与、逻辑或、逻辑非三种运算符，也是用于比较的。

· 位运算符：用于对二进制数的位进行左移、右移、取反等操作。

· 赋值运算符：用于将一个值进行赋值，例如=、+=、-=等。

算数运算符

%：计算余数。5%2 就是5除以2的余数，5%2=1

object 运算 {
      def main(args: Array[String]): Unit = {
    // 算术运算符

        println(7/4)
        //数据类型  7是Int 4是Int 所以结果为Int
        println(7/4.0)
        //数据类型  7是Int 4是Double 所以结果为Double
        println(7%4)
        println(7-4)
        println(7+4)
        println(7*4)
      }
    }

注意：7/4=1，7/4.0=1.75

原因： 7的数据类型是Int 4的数据类型是Int 所以结果的数据类型为Int； 7的数据类型是Int 4的数据类型是Double 所以结果的数据类型为Double

Scala中算术运算的本质总结如下：

 +相当于调用对应类型的+方法

 -相当于调用对应类型的-方法

 相当于调用对应类型的方法

 /相当于调用对应类型的/方法

 %相当于调用对应类型的%方法

关系运算符

关系运算符会得到Bool值。scala中的关系运算符如下：

//关系运算符：==，！=，>,<,>=,<=
    // 布尔值：false true

    println(7==4)//false
    println(7>4)//true
    println(7!=4)//true
    println(7<4)//false
    println(7>=4)//true
    println(7<=4)//false

逻辑运算符

Scala中的逻辑运算跟Java中一样，也是与、或、非三种情况

具体如下。 0 与：&& 运算表达式有一个为假，则整个表达式为假false。

或：|| 运算表达式有一个为真，则整个表达式为真true。

非：! 就是取反的意思，与参与表达式相反。

//逻辑运算符
    // &&  全部为真才会真    全部true ===> true  (与，并且)
    // ||  有一个为真便是真  一个true ====>true   (或者)
    // !   (非，取反)
    println( 1 > 2 && 2 > 1 ) // false
    println( 3 < 5 || 5 > 3 ) // true
    println( !(3>5) ) // true

练习

判断年份是否是闰年

object base09 {
      def main(args: Array[String]): Unit = {
        //判断闰年
        /*
        1.让用户输入一个整数，表示年份
        2.判断这个年份是否是闰年
        3.输出结果
         */
        val year:Int = scala.io.StdIn.readInt()
        // 2000 ====>是
        // 2024 ====>是
        // 2025 ====>不是
        // 1900 ====>不是
        var result:Boolean=  (year % 4 == 0 && year%100!=0) ||(year%400==0)
        if(result){
          println(s"$year 是闰年")
        }
        else{
          println(s"$year 不是闰年")
        }

      }
    }

赋值运算

= 简单的赋值运算，指定将右边操作数赋值给左边的操作数

+= 相加后再赋值，将左右两边的操作数相加后再赋值给左边的操作数

-= 相减后再赋值，将左右两边的操作数相减后再赋值给左边的操作数

*= 相乘后再赋值，将左右两边的操作数相乘后再赋值给左边的操作数

/= 相除后再赋值，将左右两边的操作数相除后再赋值给左边的操作数

%= 求余后再赋值，将左右两边的操作数进行求余操作后再赋值给左边的操作数

    //赋值运算符
    var a=1.0//把右边的结果，保存到左边的变量
    //a += 2// +=  等价于 a= a+2  1+2=3
    //a -= 3// -=  等价于 a= a-3  1-3=-2
    //a *= 3// *=  等价于 a= a*3  1*3=3
    //a /= 3// /=  等价于 a= a/3  1/3=0
    //a /=4//  a=1.0    1.0/4 = 0.25
    //a %= 3// %=  等价于 a= a-3   1/3的余数=1
    //a %= 4// %=  a==1.0    1.0/4的余数=1.0

    println(a)

位运算

1. & 按位与运算符。0&1 = 0,  1&0= 0 , 0&0 = 0, 1&1 = 1

2. | 按位或运算符。0|1 = 1,  1|0= 1 , 0|0 = 0, 1|1 = 1

3. ^ 按位异或运算符。0^1 = 1,  1^1= 0, 0^0 = 0

4. ~ 按位取反运算符

5. << 左移运算符。右边补零，放大。

6. >> 右移运算符。左边补零，缩小。

//位运算
    /*
     + (5|4) ) // 5
    println("5 ^ 4 =" + (5^4) ) // 1
    println("4 >> 2 ="1.& 按位与运算符。0&1 = 0,  1&0= 0 , 0&0 = 0, 1&1 = 1
    2.| 按位或运算符。0|1 = 1,  1|0= 1 , 0|0 = 0, 1|1 = 1
    3.^ 按位异或运算符。0^1 = 1,  1^1= 0, 0^0 = 0
    4.~ 按位取反运算符
      5.<< 左移运算符。右边补零，放大。
    6.>> 右移运算符。左边补零，缩小。
    */

  var a = 5; // 101
        var b = 4  // 100
        println("5 & 4 =" + (5&4) ) // 0
        println("5 | 4 =" + (4>>2) ) // 1
        println("4 << 2 =" + (4<<2) ) // 16

优先级

1. 乘(*)除(/)模(%) > 加(+)减(-)

2. 算术(+-*/%) > 关系(><>=!=) > 赋值(=)

3. && >

精度

    //精度
    var a = 0.1 + 0.2 == 0.3 // false
    var b = 0.2 + 0.2 == 0.4 // true
    var c =BigDecimal(0.1) + BigDecimal(0.2) == BigDecimal(0.3)
    println(a)
    println(b)
    println(c)

大数问题

一种整数都有自己的表达范围，一旦超过了这个范围就会报错，或者是导致计算异常。用BigInt解决。

object Main {
	def main(args: Array[String]) = {
		// BigInt 
		    var a = BigInt("111111111111111111111111111111111")
            var b = BigInt("111111111111111111111111111111111")
            var c = a*b
            println(c)
	}
}