Scala 运算符

Scala 提供了丰富的运算符，包括算术运算符、关系运算符、逻辑运算符等。在 Scala 中，运算符实际上是方法的语法糖。

算术运算符

object ArithmeticOperators {
  def main(args: Array[String]): Unit = {
    val a = 10
    val b = 3
    
    println(s"a + b = ${a + b}")  // 加法：13
    println(s"a - b = ${a - b}")  // 减法：7
    println(s"a * b = ${a * b}")  // 乘法：30
    println(s"a / b = ${a / b}")  // 除法：3
    println(s"a % b = ${a % b}")  // 取模：1
    
    // 浮点数运算
    val x = 10.0
    val y = 3.0
    println(s"x / y = ${x / y}")  // 3.3333333333333335
  }
}

关系运算符

object RelationalOperators {
  def main(args: Array[String]): Unit = {
    val a = 10
    val b = 20
    
    println(s"a == b: ${a == b}")  // 等于：false
    println(s"a != b: ${a != b}")  // 不等于：true
    println(s"a > b: ${a > b}")    // 大于：false
    println(s"a < b: ${a < b}")    // 小于：true
    println(s"a >= b: ${a >= b}")  // 大于等于：false
    println(s"a <= b: ${a <= b}")  // 小于等于：true
  }
}

逻辑运算符

object LogicalOperators {
  def main(args: Array[String]): Unit = {
    val a = true
    val b = false
    
    println(s"a && b: ${a && b}")  // 逻辑与：false
    println(s"a || b: ${a || b}")  // 逻辑或：true
    println(s"!a: ${!a}")          // 逻辑非：false
    
    // 短路求值
    val x = 5
    val result1 = x > 0 && x < 10  // true
    val result2 = x < 0 || x > 3   // true
    
    println(s"result1: $result1")
    println(s"result2: $result2")
  }
}

位运算符

object BitwiseOperators {
  def main(args: Array[String]): Unit = {
    val a = 12  // 二进制：1100
    val b = 10  // 二进制：1010
    
    println(s"a & b = ${a & b}")   // 按位与：8 (1000)
    println(s"a | b = ${a | b}")   // 按位或：14 (1110)
    println(s"a ^ b = ${a ^ b}")   // 按位异或：6 (0110)
    println(s"~a = ${~a}")         // 按位取反：-13
    println(s"a << 2 = ${a << 2}") // 左移：48 (110000)
    println(s"a >> 2 = ${a >> 2}") // 右移：3 (11)
  }
}

赋值运算符

object AssignmentOperators {
  def main(args: Array[String]): Unit = {
    var a = 10
    
    a += 5   // a = a + 5
    println(s"a += 5: $a")  // 15
    
    a -= 3   // a = a - 3
    println(s"a -= 3: $a")  // 12
    
    a *= 2   // a = a * 2
    println(s"a *= 2: $a")  // 24
    
    a /= 4   // a = a / 4
    println(s"a /= 4: $a")  // 6
    
    a %= 4   // a = a % 4
    println(s"a %= 4: $a")  // 2
  }
}

运算符优先级

Scala 运算符的优先级从高到低：

1. () [] .
2. ! ~ 一元 + -
3. * / %
4. + -
5. << >> >>>
6. < <= > >=
7. == !=
8. &
9. ^
10. |
11. &&
12. ||
13. = += -= 等赋值运算符

object OperatorPrecedence {
  def main(args: Array[String]): Unit = {
    val result1 = 2 + 3 * 4      // 14 (不是 20)
    val result2 = (2 + 3) * 4    // 20
    val result3 = 10 > 5 && 3 < 8 // true
    
    println(s"2 + 3 * 4 = $result1")
    println(s"(2 + 3) * 4 = $result2")
    println(s"10 > 5 && 3 < 8 = $result3")
  }
}

自定义运算符

在 Scala 中，可以定义自定义运算符：

class Vector2D(val x: Double, val y: Double) {
  // 定义 + 运算符
  def +(other: Vector2D): Vector2D = {
    new Vector2D(x + other.x, y + other.y)
  }
  
  // 定义 * 运算符（标量乘法）
  def *(scalar: Double): Vector2D = {
    new Vector2D(x * scalar, y * scalar)
  }
  
  // 定义自定义运算符
  def ++(other: Vector2D): Vector2D = {
    new Vector2D(x + other.x * 2, y + other.y * 2)
  }
  
  override def toString: String = s"Vector2D($x, $y)"
}

object CustomOperators {
  def main(args: Array[String]): Unit = {
    val v1 = new Vector2D(1.0, 2.0)
    val v2 = new Vector2D(3.0, 4.0)
    
    val sum = v1 + v2
    val scaled = v1 * 2.0
    val custom = v1 ++ v2
    
    println(s"v1 + v2 = $sum")      // Vector2D(4.0, 6.0)
    println(s"v1 * 2.0 = $scaled")  // Vector2D(2.0, 4.0)
    println(s"v1 ++ v2 = $custom")  // Vector2D(7.0, 10.0)
  }
}

运算符的方法调用形式

在 Scala 中，运算符实际上是方法调用的语法糖：

object OperatorMethods {
  def main(args: Array[String]): Unit = {
    val a = 10
    val b = 5
    
    // 以下两种写法是等价的
    println(a + b)        // 运算符形式
    println(a.+(b))       // 方法调用形式
    
    println(a * b)        // 运算符形式
    println(a.*(b))       // 方法调用形式
    
    // 字符串操作
    val str1 = "Hello"
    val str2 = "World"
    
    println(str1 + " " + str2)           // 运算符形式
    println(str1.+(" ").+(str2))         // 方法调用形式
  }
}

特殊运算符

Option 类型的运算符

object OptionOperators {
  def main(args: Array[String]): Unit = {
    val opt1: Option[Int] = Some(10)
    val opt2: Option[Int] = None
    
    // getOrElse 运算符
    println(opt1.getOrElse(0))  // 10
    println(opt2.getOrElse(0))  // 0
    
    // map 运算符
    val doubled = opt1.map(_ * 2)
    println(doubled)  // Some(20)
    
    // flatMap 运算符
    val result = opt1.flatMap(x => Some(x + 5))
    println(result)   // Some(15)
  }
}

集合运算符

object CollectionOperators {
  def main(args: Array[String]): Unit = {
    val list1 = List(1, 2, 3)
    val list2 = List(4, 5, 6)
    
    // :: 运算符（cons）
    val newList = 0 :: list1
    println(newList)  // List(0, 1, 2, 3)
    
    // ::: 运算符（连接）
    val combined = list1 ::: list2
    println(combined)  // List(1, 2, 3, 4, 5, 6)
    
    // ++ 运算符（连接）
    val concatenated = list1 ++ list2
    println(concatenated)  // List(1, 2, 3, 4, 5, 6)
  }
}

实践练习

1. 创建一个计算器类，实现基本的四则运算
2. 定义一个复数类，实现复数的加法和乘法运算符
3. 使用位运算符实现简单的权限系统

// 练习1：计算器类
class Calculator {
  def add(a: Double, b: Double): Double = a + b
  def subtract(a: Double, b: Double): Double = a - b
  def multiply(a: Double, b: Double): Double = a * b
  def divide(a: Double, b: Double): Double = {
    if (b != 0) a / b
    else throw new IllegalArgumentException("Division by zero")
  }
}

// 练习2：复数类
class Complex(val real: Double, val imaginary: Double) {
  def +(other: Complex): Complex = {
    new Complex(real + other.real, imaginary + other.imaginary)
  }
  
  def *(other: Complex): Complex = {
    val newReal = real * other.real - imaginary * other.imaginary
    val newImaginary = real * other.imaginary + imaginary * other.real
    new Complex(newReal, newImaginary)
  }
  
  override def toString: String = {
    if (imaginary >= 0) s"$real + ${imaginary}i"
    else s"$real - ${-imaginary}i"
  }
}

// 练习3：权限系统
object PermissionSystem {
  val READ = 1    // 001
  val WRITE = 2   // 010
  val EXECUTE = 4 // 100
  
  def hasPermission(userPermissions: Int, requiredPermission: Int): Boolean = {
    (userPermissions & requiredPermission) == requiredPermission
  }
  
  def addPermission(userPermissions: Int, newPermission: Int): Int = {
    userPermissions | newPermission
  }
  
  def removePermission(userPermissions: Int, permissionToRemove: Int): Int = {
    userPermissions & ~permissionToRemove
  }
}

运算符是 Scala 编程的基础，掌握它们的使用对于编写高效、可读的代码非常重要。