×

Scala Tutorial

Scala Basics

Scala Control statements

Scala Functions

Scala Arrays

Scala Lists

Scala Strings

Scala Classes & Objects

Scala Collections

Scala Operators

By IncludeHelp Last updated : October 09, 2024

What are operators in Scala?

Scala operators are symbols that represent operations that is to be performed in the program. Operators tell the compiler to perform a specific operation, each operator is associated with one and has a unique identification code. Operators play an important role in programming and they are used to make an expression that executes to perform a task. It defines that operation between operands, based on the operator their can be one, two or three operands.

Types of Scala Operators

Scala as a huge range of operator that can be used while programming in Scala. They are:

  1. Arithmetic operators
  2. Relational operators
  3. Logical operators
  4. Bitwise operators
  5. Assignment operators

1) Scala Arithmetic Operators

For performing arithmetic operations in Scala, arithmetic operators are defined. The following arithmetic operators are defined in Scala,

Operator Description
Addition Operator (+) Adds two operands
12 + 45 = 57
Subtraction Operator (-) Subtracts second operator from first
23 - 4 = 19
Multiplication Operator (*) Multiplies the two operands
25 *6 = 150
Division Operator (/) Divides the first operator by second
124/4 = 31
Modulus Operator (%) Gives the remainder when the first operator is divided by the second
123 % 5 = 3

Example

object ArithmeticOperatorsExample {
  def main(args: Array[String]): Unit = {
    val a = 10
    val b = 5

    // Addition
    val sum = a + b
    println(s"Addition: $a + $b = $sum")

    // Subtraction
    val difference = a - b
    println(s"Subtraction: $a - $b = $difference")

    // Multiplication
    val product = a * b
    println(s"Multiplication: $a * $b = $product")

    // Division
    val quotient = a / b
    println(s"Division: $a / $b = $quotient")

    // Modulus (remainder)
    val remainder = a % b
    println(s"Modulus: $a % $b = $remainder")
  }
}

Output

Addition: 10 + 5 = 15
Subtraction: 10 - 5 = 5
Multiplication: 10 * 5 = 50
Division: 10 / 5 = 2
Modulus: 10 % 5 = 0

2) Scala Relational Operators

A relational operator is used to define the comparison between the two operators. It is also known as a comparison operator. Following are relational Operators in Scala,

Operator Description
Equal to (==) Compares if the two operands are equal, if yes then outputs TRUE else FALSE
12 == 34 → FALSE
23 == (46/2) → TRUE
Not Equal to (!=) Compares if the two operands are not equal, if yes then outputs TRUE else FALSE
12 != 34 → TRUE
23 != (46/2) → FALSE
Greater than (>) Checks if operand 1 is greater than operand 2. If yes outputs true otherwise false
34 > 2 → TRUE
34 >334 → FALSE
Greater than equal to (>=) Checks if operand 1 is greater than or equal to operand 2. If yes outputs true otherwise false
34 >= 2 → TRUE
34 >=334 → FALSE
34 >= 34 → TRUE
Less than (<) Checks if operand 1 is smaller than operand 2. If yes outputs true otherwise false
34 < 2 → FALSE
34 < 334 → TRUE
Less than equal to (<=) Checks if operand 1 is smaller than or equal to operand 2. If yes outputs true otherwise false
34 <= 2 → FALSE
34 <= 334 → TRUE
34 <= 34 → TRUE

Example

object RelationalOperatorsExample {
  def main(args: Array[String]): Unit = {
    val a = 10
    val b = 5

    // Equal to
    val isEqual = a == b
    println(s"$a == $b : $isEqual")

    // Not equal to
    val isNotEqual = a != b
    println(s"$a != $b : $isNotEqual")

    // Greater than
    val isGreaterThan = a > b
    println(s"$a > $b : $isGreaterThan")

    // Less than
    val isLessThan = a < b
    println(s"$a < $b : $isLessThan")

    // Greater than or equal to
    val isGreaterThanOrEqual = a >= b
    println(s"$a >= $b : $isGreaterThanOrEqual")

    // Less than or equal to
    val isLessThanOrEqual = a <= b
    println(s"$a <= $b : $isLessThanOrEqual")
  }
}

Output

10 == 5 : false
10 != 5 : true
10 > 5 : true
10 < 5 : false
10 >= 5 : true
10 <= 5 : false

3) Scala Logical Operators

A logical Operator is used to combine the logical output (true / False ) or reverse to the logical output of a condition or operand. Scala defines the following logical operators,

Operator Description
And (&& or and) It outputs TRUE, if the logical value of both operands is TRUE, else outputs FALSE.
OR (|| or or) It outputs FALSE, if the logical value of both operands is FALSE, else outputs TRUE.
NOT (! or not) It reverses the output of the operand.

The results of and , or and, not operator based on different values of operand:

A B A && B A || B !A
True True True True False
True False False True False
False True False True True
False False False False True

Example

object LogicalOperatorsExample {
  def main(args: Array[String]): Unit = {
    val a = true
    val b = false

    // Logical AND (&&)
    val andResult = a && b
    println(s"$a && $b : $andResult")

    // Logical OR (||)
    val orResult = a || b
    println(s"$a || $b : $orResult")

    // Logical NOT (!)
    val notA = !a
    val notB = !b
    println(s"!$a : $notA")
    println(s"!$b : $notB")
  }
}

Output

true && false : false
true || false : true
!true : false
!false : true

4) Scala Bitwise Operators

It works on the bits of the operands. It operates on every bit of the operands to give output. The following are valid bitwise operators in Scala,

Operator Description
Bitwise AND (&) It takes every bit of both operands and performs AND operation to it.
2 & 6 = 2 -> 010 & 110 = 010
Bitwise OR (|) It takes every bit of both operands and performs OR operation to it.
2 | 6 = 6 -> 0010 | 0110 = 0110
Bitwise XOR (^) It takes every bit of both operands and performs XOR operation to it.
XOR operation gives 1 output when both operands are different.
2 ^ 6 = 4 -> 0010 ^ 0110 = 0100
Bitwise Left Shift (<<) It shifts left the bits of operand 1 by n bits; n is specified by operand 2.
12 << 3 = 96 -> 0000 1100 << 3 = 0110 0000
Bitwise Right Shift (>>) It shifts right the bits of operand 1 by n bits; n is specified by operand 2.
12 >> 3 = 129 -> 0000 1100 >> 3 = 1000 0001
Bitwise Right Shift zero fill (>>>) It shifts the bits of operand 1 by n bits; n is specified by operand 2. And fills the shifted bit by 0.
12 >>> 3 = 1 ->0000 1100 >>> 3 000 0001
Bitwise Complement (~) It takes every bit of the operand and reverses its bits.
~12 = 243 -> ~ (0000 1100) = 1111 0011

Example

object BitwiseOperatorsExample {
  def main(args: Array[String]): Unit = {
    val a = 12    // Binary: 1100
    val b = 5     // Binary: 0101

    // Bitwise AND (&)
    val andResult = a & b   // Binary: 0100 (Decimal: 4)
    println(s"$a & $b = $andResult")

    // Bitwise OR (|)
    val orResult = a | b    // Binary: 1101 (Decimal: 13)
    println(s"$a | $b = $orResult")

    // Bitwise XOR (^)
    val xorResult = a ^ b   // Binary: 1001 (Decimal: 9)
    println(s"$a ^ $b = $xorResult")

    // Bitwise NOT (~)
    val notA = ~a           // Binary: 0011... (Inverts all bits, result depends on word size)
    println(s"~$a = $notA")

    // Left Shift (<<)
    val leftShift = a << 2  // Binary: 110000 (Decimal: 48)
    println(s"$a << 2 = $leftShift")

    // Right Shift (>>)
    val rightShift = a >> 2 // Binary: 0011 (Decimal: 3)
    println(s"$a >> 2 = $rightShift")

    // Unsigned Right Shift (>>>)
    val unsignedRightShift = a >>> 2 // Binary: 0011 (Decimal: 3, same as >> in this case)
    println(s"$a >>> 2 = $unsignedRightShift")
  }
}

Output

12 & 5 = 4
12 | 5 = 13
12 ^ 5 = 9
~12 = -13
12 << 2 = 48
12 >> 2 = 3
12 >>> 2 = 3

5) Scala Assignment Operators

The assignment operator is used to assign value to a variable. The variable is at the left of the operator and value is at the right of the operator. The data type needs to be the same for both sides to avoid errors in the program.

The following are valid assignment operators in Scala,

Operator Description
Simple Assignment (=) It simply assigns the value at left to the variable at right.
a = 2432;
Add and assign (+=) It adds the left value to the right value.
c += 32 -> c = c + 32
Subtract and assign (-=) It subtracts the left value from the right value.
c -= 32 -> c = c - 32
Multiply and assign (*=) It multiplies the left value with the right value.
c *= 32 -> c = c * 32
Divide and assign (/=) It divides the left value from the right value.
c /= 32 -> c = c / 32
Remainder and assign (%=) It finds the modulus of to the right value divide by left value.
c %= 32 -> c = c % 32
Left Shift and assign (>>=) It shifts the bits of left operands by n , n defined by right operator and assigns this value to left operator.
i >>= 6 -> i = i >> 6
Right Shift and assign (<<=) It shifts the bits of right operands by n , n defined by right operator and assigns this value to left operator.
i <<= 6 -> i = i << 6
Bitwise and assignment (&=) It performs the bitwise and operation of left operand and right operand and assigns this value to left operator.
i &= 6 -> i = i & 6
Bitwise exclusive OR assignment (^=) It performs the bitwise exclusive OR operation of left operand and right operand and assigns this value to left operator.
i ^= 6 -> i = i & 6

Example

object AssignmentOperatorsExample {
  def main(args: Array[String]): Unit = {
    var a = 10
    var b = 5

    // Simple assignment
    println(s"Initial value of a: $a")
    println(s"Initial value of b: $b")

    // Add and assign (+=)
    a += b  // a = a + b
    println(s"After a += b: $a")

    // Subtract and assign (-=)
    a -= b  // a = a - b
    println(s"After a -= b: $a")

    // Multiply and assign (*=)
    a *= b  // a = a * b
    println(s"After a *= b: $a")

    // Divide and assign (/=)
    a /= b  // a = a / b
    println(s"After a /= b: $a")

    // Modulus and assign (%=)
    a %= b  // a = a % b
    println(s"After a %= b: $a")

    // Bitwise AND and assign (&=)
    a = 12  // Binary: 1100
    b = 5   // Binary: 0101
    a &= b  // a = a & b (Binary: 0100, Decimal: 4)
    println(s"After a &= b: $a")

    // Bitwise OR and assign (|=)
    a |= b  // a = a | b (Binary: 0101, Decimal: 5)
    println(s"After a |= b: $a")

    // Bitwise XOR and assign (^=)
    a ^= b  // a = a ^ b (Binary: 0000, Decimal: 0)
    println(s"After a ^= b: $a")

    // Left shift and assign (<<=)
    a = 3   // Binary: 0011
    a <<= 2 // a = a << 2 (Binary: 1100, Decimal: 12)
    println(s"After a <<= 2: $a")

    // Right shift and assign (>>=)
    a >>= 2 // a = a >> 2 (Binary: 0011, Decimal: 3)
    println(s"After a >>= 2: $a")

    // Unsigned right shift and assign (>>>=)
    a >>>= 1 // a = a >>> 1 (Binary: 0001, Decimal: 1)
    println(s"After a >>>= 1: $a")
  }
}

Output

Initial value of a: 10
Initial value of b: 5
After a += b: 15
After a -= b: 10
After a *= b: 50
After a /= b: 10
After a %= b: 0
After a &= b: 4
After a |= b: 5
After a ^= b: 0
After a <<= 2: 12
After a >>= 2: 3
After a >>>= 1: 1

All the operators are applied in Scala as it is and you can use them easily but to avoid error data type of operands should be the same.

Comments and Discussions!

Load comments ↻





Copyright © 2024 www.includehelp.com. All rights reserved.