![\"What](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/04\/Scala-Operators-01.jpg\")
<\/a>What is Scala Operator – 6 Major Types of Operators in Scala<\/p><\/div>\n
What are the Operators in Scala?<\/h3>\n
A symbol that instructs the compiler to perform certain mathematical or logical manipulations, is an operator.<\/p>\n
Types of Scala Operators<\/h3>\n
We have the following types of Scala Operator:<\/p>\n
- \n
- Arithmetic Operators<\/li>\n
- Relational Operators<\/li>\n
- Logical Operators<\/li>\n
- Bitwise Operators<\/li>\n
- Assignment Operators<\/li>\n<\/ul>\n
Let\u2019s discuss all Scala operator one by one.<\/p>\n
a. Arithmetic Operators in Scala<\/h4>\n
This Scala operator tells Scala to perform arithmetic operations on two values. We have five of these. Let\u2019s take two values for exemplary purposes. (We did this in the Command Prompt).<\/p>\n
scala> val a=2\r\na: Int = 2\r\nscala> val b=3\r\nb: Int = 3<\/pre>\n
i. Addition (+)<\/h5>\n
This adds two operands. See an example.<\/p>\n
scala> a+b\r\nres0: Int = 5<\/pre>\n
ii. Subtraction (-)<\/h5>\n
This subtracts the second operand from the first.<\/p>\n
scala> a-b\r\nres1: Int = -1<\/pre>\n
iii. Multiplication (*)<\/h5>\n
This multiplies the two operands.<\/p>\n
scala> a*b\r\nres2: Int = 6<\/pre>\n
iv. Division (\/)<\/h5>\n
This divides the first value by the second.<\/p>\n
scala> a\/b\r\nres3: Int = 0\r\nscala> b\/a\r\nres4: Int = 1<\/pre>\n
v. Modulus (%)<\/h5>\n
This returns the remainder after dividing the first number by the second.<\/p>\n
scala> a%b\r\nres6: Int = 2\r\nscala> b%a\r\nres5: Int = 1<\/pre>\n
b. Relational Operators in Scala<\/h4>\n
Now, let\u2019s discuss the Scala operator that let us compare values. They are rational Scala Operator.<\/p>\n
i. Equal to (==)<\/h5>\n
This returns true if the two values are equal; otherwise, false.<\/p>\n
scala> a==b\r\nres7: Boolean = false\r\nscala> println(a==b)\r\nfalse<\/pre>\n
ii. Not Equal to (!=)<\/h5>\n
This returns true if the two values are unequal; otherwise, false.<\/p>\n
scala> a!=b\r\nres9: Boolean = true<\/pre>\n
iii. Greater Than (>)<\/h5>\n
This returns true if the first operand is greater than the second; otherwise, false.<\/p>\n
scala> a>b\r\nres10: Boolean = false<\/pre>\n
iv. Less Than (<)<\/h5>\n
This returns true if the first operand is lesser than the second; otherwise, false.<\/p>\n
scala> a<b\r\nres11: Boolean = true<\/pre>\n
v. Greater Than or Equal to (>=)<\/h5>\n
This returns true if the first operand is greater than or equal to the second; otherwise, false.<\/p>\n
scala> a>=b\r\nres12: Boolean = false<\/pre>\n
vi. Less Than or Equal to (<=)<\/h5>\n
This returns true if the first operand is less than or equal to the second; otherwise, false.<\/p>\n
scala> a<=b\r\nres13: Boolean = true<\/pre>\n
c. Logical Operators in Scala<\/h4>\n
Moving on to logical Scala operator, we have three. Let\u2019s take Boolean values for this.<\/p>\n
i. Logical AND (&&)<\/h5>\n
This returns true if both operands are true; otherwise, false.<\/p>\n
scala> true&&true\r\nres22: Boolean = true\r\nscala> true&&false\r\nres23: Boolean = false<\/pre>\n
ii. Logical OR (||)<\/h5>\n
This returns true if either or both operands are true; otherwise, false.<\/p>\n
scala> true||false\r\nres25: Boolean = true\r\nscala> false||false\r\nres26: Boolean = false<\/pre>\n
iii. Logical NOT (!)<\/h5>\n
This reverses the operand\u2019s logical state. It turns true to false, and false to true.<\/p>\n
scala> !true\r\nres27: Boolean = false\r\nscala> !false\r\nres28: Boolean = true\r\nscala> !(true&&false)\r\nres29: Boolean = true<\/pre>\n
d. Bitwise Operators in Scala<\/h4>\n
Coming to Bitwise Scala operator, we have seven in Scala. But first, let\u2019s see the truth table for these:<\/p>\n
\n\n
\n p<\/b><\/td>\n q<\/b><\/td>\n p&q<\/b><\/td>\n p|q<\/b><\/td>\n p^q<\/b><\/td>\n<\/tr>\n \n 0<\/td>\n 0<\/td>\n 0<\/td>\n 0<\/td>\n 0<\/td>\n<\/tr>\n \n 0<\/td>\n 1<\/td>\n 0<\/td>\n 1<\/td>\n 1<\/td>\n<\/tr>\n \n 1<\/td>\n 0<\/td>\n 0<\/td>\n 1<\/td>\n 1<\/td>\n<\/tr>\n \n 1<\/td>\n 1<\/td>\n 1<\/td>\n 1<\/td>\n 0<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Let\u2019s take two values:<\/p>\n
scala> var a=60 \/\/Its binary is 00111100\r\na: Int = 60\r\nscala> var b=13 \/\/Its binary is 00001101\r\nb: Int = 13<\/pre>\n
i. Binary AND Operator (&)<\/h5>\n
This performs an AND operation on each pair of bits in the binary equivalents for the two operands.<\/p>\n
scala> a&b\r\nres43: Int = 12\r\n<\/pre>\n
This gives us 12 because of 00001100.<\/p>\n
ii. Binary OR Operator (|)<\/h5>\n
This performs an OR operation on each pair of bits in the binary equivalents for the two operands.<\/p>\n
scala> a|b\r\nres44: Int = 61<\/pre>\n
The result is 61 because of 00111101.<\/p>\n
iii. Binary XOR Operator (^)<\/h5>\n
This Scala Operator performs an XOR operation on each pair of bits in the binary equivalents for the two operands.<\/p>\n
scala> a^b\r\nres45: Int = 49<\/pre>\n
49 is decimal for 00110001.<\/p>\n
iv. Binary One\u2019s Complement (~)<\/h5>\n
This flips the bits in the operand\u2019s binary equivalent.<\/p>\n
scala> ~a \/\/This will be 11000011\r\nres46: Int = -61\r\nscala> ~b\r\nres47: Int = -14<\/pre>\n
v. Binary Left-Shift Operator (<<)<\/h5>\n
This Scala operator moves the bits of the left operand by (the right operand) number of bits to the left.<\/p>\n
scala> a<<2\r\nres48: Int = 240<\/pre>\n
This is because it turns 00111100 to 11110000.<\/p>\n
vi. Binary Right-Shift Operator (>>)<\/h5>\n
This Scala Operator moves the bits of the left operand by (the right operand) number of bits to the right.<\/p>\n
scala> a>>2\r\nres49: Int = 15<\/pre>\n
This is because it turns 00111100 to 1111.<\/p>\n
vii. Shift Right Zero Fill Operator (>>>)<\/h5>\n
Shift Right Zero Fill Scala Operator moves the bits of the left operand by (the right operand) number of bits to the right, and fills these places with zeroes.<\/p>\n
scala> a>>>2\r\nres50: Int = 15<\/pre>\n
This turns 00111100 to 00001111.<\/p>\n
e. Assignment Operators in Scala<\/h4>\n
Scala supports 11 different assignment operators:<\/p>\n
i. Simple Assignment Operator (=)<\/h5>\n
This assigns the value on the right to the operand on the left.<\/p>\n
scala> var a=1+2\r\na: Int = 3<\/pre>\n
ii. Add and Assignment Operator (+=)<\/h5>\n
This Scala Operator adds the value of the right operand to the one on the left, and then assigns the result to the left operand.<\/p>\n
scala> a+=2 \/\/This is the same as a=a+2\r\nscala> a\r\nres31: Int = 5<\/pre>\n
iii. Subtract and Assignment Operator (-=)<\/h5>\n
This Scala operator subtracts the second operand from the first, then assigns the result to the left operand.<\/p>\n
scala> a-=3\r\nscala> a\r\nres33: Int = 2<\/pre>\n
iv. Multiply and Assignment Operator (*=)<\/h5>\n
This Scala Operator multiplies the two operands, and then assigns the result to the left operand.<\/p>\n
scala>\u00a0a*=7\r\nscala> a\r\nres38: Int = 14<\/pre>\n
v. Divide and Assignment Operator (\/=)<\/h5>\n
Divide And Assignment Scala Operator divides the first operand by the second, and then assigns the result to the left operand.<\/p>\n
scala> a\/=2\r\nscala> a\r\nres40: Int = 7<\/pre>\n
vi. Modulus and Assignment Operator (%=)<\/h5>\n
Modulus And Assignment Scala Operator calculates the modulus remaining after dividing the first operand by the second. Then, it assigns this result to the first operand.<\/p>\n
scala> a%=4\r\nscala> a\r\nres42: Int = 3<\/pre>\n
vii. Left-Shift and Assignment Operator (<<=)<\/h5>\n
This Scala operator shifts the left operand by (the right operand) number of bits to the left. Then, it assigns the result to the left operand.<\/p>\n
scala> a<<=2\r\nscala> a\r\nres57: Int = 240<\/pre>\n
We\u2019ll reset a to 60 every time so we can properly demonstrate the operators.<\/p>\n
scala> a=60\r\na: Int = 60<\/pre>\n
viii. Right-Shift and Assignment Operator (>>=)<\/h5>\n
This Scala Operator shifts the left operand by (the right operand) number of bits to the right. Then, it assigns the result to the left operand.<\/p>\n
scala> a>>=2\r\nscala> a\r\nres59: Int = 15\r\nscala> a=60\r\na: Int = 60<\/pre>\n
ix. Bitwise AND Assignment Operator (&=)<\/h5>\n
This applies the bitwise AND operator on the two operands, and then assigns the result to the left operand.<\/p>\n
scala> a&=b\r\nscala> a\r\nres61: Int = 12\r\nscala> a=60\r\na: Int = 60<\/pre>\n
x. Bitwise Exclusive-OR and Assignment Operator (^=)<\/h5>\n
This performs a bitwise XOR operation on the two operands, and then assigns this result to the left operand.<\/p>\n
scala> a^=b\r\nscala> a\r\nres63: Int = 49\r\nscala> a=60\r\na: Int = 60<\/pre>\n
xi. Bitwise Inclusive-OR and Assignment Operator (|=)<\/h5>\n
This performs a bitwise-inclusive-OR operation on the two operands, and then assigns this result to the left operand.<\/p>\n
scala> a|=b\r\nscala> a\r\nres65: Int = 61<\/pre>\n
Scala Operator Precedence<\/h3>\n
When we use multiple terms in an expression, how does Scala group them? This is decided by Scala operator precedence; this is how an expression evaluates. Some Scala operators have a higher precedence than others:<\/p>\n
\n\n
\n Category<\/b><\/td>\n Operator<\/b><\/td>\n Associativity<\/b><\/td>\n<\/tr>\n \n Postfix<\/td>\n () []<\/td>\n Left to Right<\/td>\n<\/tr>\n \n Unary<\/td>\n ! ~<\/td>\n Right to Left<\/td>\n<\/tr>\n \n Multiplicative<\/td>\n * \/ %<\/td>\n Left to Right<\/td>\n<\/tr>\n \n Additive<\/td>\n + –<\/td>\n Left to Right<\/td>\n<\/tr>\n \n Shift<\/td>\n >> >>> <<<\/td>\n Left to Right<\/td>\n<\/tr>\n \n Relational<\/td>\n > >= < <=<\/td>\n Left to Right<\/td>\n<\/tr>\n \n Equality<\/td>\n == !=<\/td>\n Left to Right<\/td>\n<\/tr>\n \n Bitwise AND<\/td>\n &<\/td>\n Left to Right<\/td>\n<\/tr>\n \n Bitwise XOR<\/td>\n ^<\/td>\n Left to Right<\/td>\n<\/tr>\n \n Bitwise OR<\/td>\n |<\/td>\n Left to Right<\/td>\n<\/tr>\n \n Logical AND<\/td>\n &&<\/td>\n Left to Right<\/td>\n<\/tr>\n \n Logical OR<\/td>\n ||<\/td>\n Left to Right<\/td>\n<\/tr>\n \n Assignment<\/td>\n = += -= *= \/= %= >>= <<= &= ^= |=<\/td>\n Right to Left<\/td>\n<\/tr>\n \n Comma<\/td>\n ,<\/td>\n Left to Right<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n In the table, the precedence decreases from top to bottom. Hence, the topmost operators have the highest precedencies. In an expression, the operators with a higher precedence evaluate first.<\/p>\n
For example, in val x=7+7*7, what evaluates first is 7*7, because * has a higher precedence than +. Then, 7+49 gives us 56.<\/p>\n
So, this was all about Scala Operator. Hope you like our explanation.<\/p>\n
Conclusion<\/h3>\n
Hence, we discussed types of Scala operators:\u00a0Arithmetic, Relational, Logical, Bitwise, Assignment Operators in Scala with their subtypes and examples.\u00a0Tell us what you think in the comments section.<\/p>\n