# Scala Operator – Arithmetic, Relational, Logical, Bitwise, Assignment

Filed Under: Scala

Today we will look into various types of scala operator. An operator tells the compiler to perform specific mathematical or logical operations.

## Scala Operator

The following types of operators are supported in Scala programming language.

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

Let’s go through with each of them one by one with examples.

### Scala Arithmetic Operators

Arithmetic operators include the basic operations like Addition, Subtraction, Multiplication, Division and Modulus. The arithmetic operators supported are +,-,*,/ and %.

 Operator Description + Adds two operands – Subtracts the second operand from the first * Multiplies two operands / Divides the numerator by the denominator % Returns the remainder

Here is an example of scala arithmetic operator.

``````
object Arithmetic {

def main(args:Array[String]) {
var x = 40;
var y = 20;

println("Addition of x + y = " + (x + y));

println("Subtraction of x - y = " + (x - y));

println("Multiplication of x * y = " + (x * y));

println("Division of x / y = " + (x / y));

println("Modulus of x % y = " + (x % y));

}
}
``````

We are defining an object Arithmetic with the main method which accepts argument of String type of array. x and y variables are declared with values 40 and 20 respectively. We are printing the result by performing operations x+y, x-y, x*y, x/y, x%y.

Note that in Scala unlike in Java we can directly create an object without first creating a class.

Run the above code after creating object Arithmetic by typing `Arithmetic.main(null)` in Scala shell.

Output:

``````
scala> Arithmetic.main(null)
Addition of x + y = 60
Subtraction of x - y = 20
Multiplication of x * y = 800
Division of x / y = 2
Modulus of x % y = 0
`````` ### Scala Relational Operators

Relational operators include ==,!=,>,<,>= and <=. The following table shows the list of relational operators in scala.

 Operator Description == Checks whether the two operands are equal or not and returns true if they are equal. != Checks if the two operands are equal or not and returns true if they are not equal. > Checks if the first operand is greater than the second and returns true if the first operand is greater than the second operand. < Checks if the first operand is lesser than the second and returns true if the first operand is lesser than the second operand. >= Checks whether the first operand is greater than or equal to the second operand and returns true if the first operand is greater than or equal to the second operand. <= Checks whether the first operand is lesser than or equal to the second operand and returns true if the first operand is lesser than or equal to the second operand.

Consider an example for relational operators in scala.

``````
object Relational {

def main(args:Array[String]) {
var x = 10;
var y = 20;

println("Equality of   x == y is : " + (x == y));

println("Not Equals of x != y is : " + (x !=y));

println("Greater than of x > y is : " + (x > y));

println("Lesser than of   x < y is : " + (x < y));

println("Greater than or Equal to of x >= y is : " + (x >= y));

println("Lesser than or Equal to of x <= y is : " + (x <= y));

}
}
``````

We are defining an object Relational with the main method which accepts argument of String type of array. x and y variables are declared with values 10 and 20 respectively. We are printing the result by performing operations x ==y, x!=y, x>y, x<y, x>=y and x <=y.

Run the above code by typing Relational.main(null)

Output:

``````
scala> Relational.main(null)
Equality of   x == y is : false
Not Equals of x != y is : true
Greater than of x > y is : false
Lesser than of   x < y is : true
Greater than or Equal to of x >= y is : false
Lesser than or Equal to of x <= y is : true
`````` ### Scala Logical Operators

Logical operators include !, || and &&. The following table shows the list of logical operators supported.

 Operator Description ! Logical NOT operand which reverses the logical state of the operand.Returns true if the condition is satisfied || Logical OR operand which returns true if any of the two operands is non zero && Logical AND operand which returns true if both the operand are non zero

Consider an example of scala logical operators.

``````
object Logical {

def main(args: Array[String]) {
var x = false
var y = true

println("Logical Not of !(x && y) = " + !(x && y) );

println("Logical Or of x || y = " + (x || y) );

println("Logical And of x && y = " + (x &&y) );

}
}
``````

We are defining an object Logical with the main method which accepts argument of String type of array. x and y are boolean variables with values false and true respectively. We are printing the result by performing operations !(x && y), x || y and x && y.

Run the above code by typing Logical.main(null)

Output:

``````
scala> Logical.main(null)
Logical Not of !(x && y) = true
Logical Or of x || y = true
Logical And of x && y = false
`````` ### Bitwise Operators in Scala

Bitwise operators include &, |, ~, ^, <<, >> and >>>. The following table shows the bitwise operators supported in Scala.

 Operator Description & Binary AND operator copies the bit to the result if the operator exists in both the operands. | Binary OR operator copies the bit to the result if the operator exists in either of the operands. ~ Binary Ones Complement Operator is unary and has effects of the flipping bits. ^ Binary XOR operator copies if the bit is set in one of the operand but not both. << Binary Left Shift operator.The left operand value is moved left by the number of bits specified in the right operand. >> Binary Right Shift operator.The left operand value is moved right by the number of bits specified by the right operand. >>> Shift right zero fill operator. The left operands value is moved right by the number of bits specified by the right operand and shifted values are filled with zeros.

Consider an example of bitwise operator in scala.

``````
object Bitwise {
def main(args: Array[String]) {
var x = 16;
var y = 12;
var z = 0;

z = x & y;
println("Bitwise And of x & y = " + z );

z = x | y;
println("Bitwise Or of x | y = " + z );

z = x ^ y;
println("Bitwise Xor of x ^ y = " + z );

z = ~x;
println("Bitwise Ones Complement of ~x = " + z );

z = x << 2;
println("Bitwise Left Shift of x << 2 = " + z );

z = x >> 2;
println("Bitwise Right Shift of x >> 2 = " + z );

z = x >>> 2;
println("Bitwise Shift Right x >>> 2 = " + z );
}
}
``````

We are defining an object Bitwise with the main method which accepts argument of String type of array. x and y are variables with values 16 and 12 respectively. We are printing the result by performing all bitwise operations.

Run the program by typing Bitwise.main(null)

Output:

``````
scala> Bitwise.main(null)
Bitwise And of x & y = 0
Bitwise Or of x | y = 28
Bitwise Xor of x ^ y = 28
Bitwise Ones Complement of ~x = -17
Bitwise Left Shift of x << 2 = 64
Bitwise Right Shift of x >> 2 = 4
Bitwise Shift Right x >>> 2 = 4
`````` ### Scala Assignment Operators

Scala Assignment operators include =,+=, -=, *=, /=, %=, <<=, >>=, &=, |= and ^=.The following table shows the list of assignment operators.

 Operator Description = Assigns value from right side operand to left side operand += Adds right operand to left operand and assigns the result to left operand -= Subtracts right operand from the left operand and assigns the result to left operand *= Multiplies right operand with the left operand and assigns the result to the left operand /= Divides the left operand with the right operand and assigns the result to the left operand %= Finds the modulus of two operands and assigns the result to left operand <<= Left shift assignment operator.It left shifts the operand and assigns result to the left operand >>= Right shift assignment operator.It rights shifts the operator and assigns the value to left operand &= Bitwise AND assignment operator performs bitwise AND operation and assigns the result to left operand |= Bitwise OR assignment operator performs bitwise OR operation and assigns result to left operand ^= Performs bitwise exclusive OR operation and assigns result to the left operand

Consider an example for assignment operators in scala.

``````
object Assignment {

def main(args: Array[String]) {
var x = 20;
var y = 30;
var z = 0;

z = x + y;
println("z= x+ y = " + z );

z+= x ;
println("Add and assignment of z += x = " + z );

z -= x ;
println("Subtract and assignment of z -= x = " + z );

z *= x ;
println("Multiplication and assignment of z *= x = " + z );

x = 20;
z = 15;
z /= x ;
println("Division and assignment of z /= x = " + z );

x = 30;
z = 15;
z %= x;
println("Modulus and assignment of z %= x = " + z );

z <<= 2;
println("Left shift and assignment of z <<= 2 = " + z );

z >>= 2;
println("Right shift and assignment of z >>= 2 = " + z );

z &= x;
println("Bitwise And assignment of z &= 2 = " +z );

z ^= x ;
println("Bitwise Xor and assignment of z ^= x = " + z );

z |= x ;
println("Bitwise Or and assignment of z |= x = " + z );
}
}
``````

We are defining an object Assignment with the main method which accepts argument of String type of array. x and y are variables. We are printing the result by performing all assignment operations.

Run the above example by tying Assignment.main(null)

Output:

``````
scala> Assignment.main(null)
z= x+ y = 50
Add and assignment of z += x = 70
Subtract and assignment of z -= x = 50
Multiplication and assignment of z *= x = 1000
Division and assignment of z /= x = 0
Modulus and assignment of z %= x = 15
Left shift and assignment of z <<= 2 = 60
Right shift and assignment of z >>= 2 = 15
Bitwise And assignment of z &= 2 = 14
Bitwise Xor and assignment of z ^= x = 16
Bitwise Or and assignment of z |= x = 30
`````` That’s all for different types of Scala Operator.

1. mallikarjun says: