And assignment operator in java

Java Operators

Operators are symbols that perform operations on variables and values. For example, + is an operator used for addition, while * is also an operator used for multiplication.

Operators in Java can be classified into 5 types:

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

1. Java Arithmetic Operators

Arithmetic operators are used to perform arithmetic operations on variables and data. For example,

Here, the + operator is used to add two variables a and b . Similarly, there are various other arithmetic operators in Java.

Example 1: Arithmetic Operators

class Main < public static void main(String[] args) < // declare variables int a = 12, b = 5; // addition operator System.out.println("a + b = " + (a + b)); // subtraction operator System.out.println("a - b = " + (a - b)); // multiplication operator System.out.println("a * b = " + (a * b)); // division operator System.out.println("a / b = " + (a / b)); // modulo operator System.out.println("a % b note-tip">Note: The % operator is mainly used with integers.
 
2. Java Assignment Operators
 
Assignment operators are used in Java to assign values to variables. For example,
 
int age; age = 5;
 
Here, = is the assignment operator. It assigns the value on its right to the variable on its left. That is, 5 is assigned to the variable age .
 
Let's see some more assignment operators available in Java.
 
 
 
 
Operator
 
Example
 
Equivalent to
 
 
 
=
 
a = b;
 
a = b;
 
 
 
+=
 
a += b;
 
a = a + b;
 
 
 
-=
 
a -= b;
 
a = a - b;
 
 
 
*=
 
a *= b;
 
a = a * b;
 
 
 
/=
 
a /= b;
 
a = a / b;
 
 
 
%=
 
a %= b;
 
a = a % b;
 
 
 
 
Example 2: Assignment Operators
 
var using =: 4 var using +=: 8 var using *=: 32
 
3. Java Relational Operators
 
Relational operators are used to check the relationship between two operands. For example,
 
// check if a is less than b a < b;
 
It returns either true or false .
 
 
 
 
Operator
 
Description
 
Example
 
 
 
==
 
Is Equal To
 
3 == 5 returns false
 
 
 
!=
 
Not Equal To
 
3 != 5 returns true
 
 
 
>
 
Greater Than
 
3 > 5 returns false
 
 
 
 
Less Than
 
3 < 5 returns true
 
 
 
>=
 
Greater Than or Equal To
 
3 >= 5 returns false
 
 
 
 
Less Than or Equal To
 
3 true
 
 
 
 
Example 3: Relational Operators
 
class Main < public static void main(String[] args) < // create variables int a = 7, b = 11; // value of a and b System.out.println("a is " + a + " and b is " + b); // == operator System.out.println(a == b); // false // != operator System.out.println(a != b); // true // >operator System.out.println(a > b); // false // < operator System.out.println(a < b); // true // >= operator System.out.println(a >= b); // false // >
 
Note: Relational operators are used in decision making and loops.
 
4. Java Logical Operators
 
Logical operators are used to check whether an expression is true or false . They are used in decision making.
 
 
 
 
Operator
 
Example
 
Meaning
 
 
 
&& (Logical AND)
 
expression1 && expression2
 
true only if both expression1 and expression2 are true
 
 
 
|| (Logical OR)
 
expression1 || expression2
 
true if either expression1 or expression2 is true
 
 
 
! (Logical NOT)
 
!expression
 
true if expression is false and vice versa
 
 
 
 
Example 4: Logical Operators
 
class Main < public static void main(String[] args) < // && operator System.out.println((5 >3) && (8 > 5)); // true System.out.println((5 > 3) && (8 < 5)); // false // || operator System.out.println((5 < 3) || (8 >5)); // true System.out.println((5 > 3) || (8 < 5)); // true System.out.println((5 < 3) || (8 < 5)); // false // ! operator System.out.println(!(5 == 3)); // true System.out.println(!(5 >3)); // false > >
 
Working of Program
 
 
(5 > 3) && (8 > 5) returns true because both (5 > 3) and (8 > 5) are true .
 
(5 > 3) && (8 < 5) returns false because the expression (8 < 5) is false .
 
(5 < 3) || (8 >5) returns true because the expression (8 > 5) is true .
 
(5 > 3) || (8 < 5) returns true because the expression (5 >3) is true .
 
(5 < 3) || (8 < 5) returns false because both (5 < 3) and (8 < 5) are false .
 
!(5 == 3) returns true because 5 == 3 is false .
 
!(5 > 3) returns false because 5 > 3 is true .
 
 
5. Java Unary Operators
 
Unary operators are used with only one operand. For example, ++ is a unary operator that increases the value of a variable by 1. That is, ++5 will return 6.
 
Different types of unary operators are:
 
 
 
 
Operator
 
Meaning
 
 
 
+
 
Unary plus: not necessary to use since numbers are positive without using it
 
 
 
-
 
Unary minus: inverts the sign of an expression
 
 
 
++
 
Increment operator: increments value by 1
 
 
 
--
 
Decrement operator: decrements value by 1
 
 
 
!
 
Logical complement operator: inverts the value of a boolean
 
 
 
 
Increment and Decrement Operators
 
Java also provides increment and decrement operators: ++ and -- respectively. ++ increases the value of the operand by 1, while -- decrease it by 1. For example,
 
int num = 5; // increase num by 1 ++num;
 
Here, the value of num gets increased to 6 from its initial value of 5.
 
Example 5: Increment and Decrement Operators
 
Value of a: 12 After increment: 13 Value of b: 12 After decrement: 11
 
In the above program, we have used the ++ and -- operator as prefixes (++a, --b). We can also use these operators as postfix (a++, b++).
 
There is a slight difference when these operators are used as prefix versus when they are used as a postfix.
 
To learn more about these operators, visit increment and decrement operators.
 
6. Java Bitwise Operators
 
Bitwise operators in Java are used to perform operations on individual bits. For example,
 
Bitwise complement Operation of 35 35 = 00100011 (In Binary) ~ 00100011 ________ 11011100 = 220 (In decimal)
 
Here, ~ is a bitwise operator. It inverts the value of each bit (0 to 1 and 1 to 0).
 
The various bitwise operators present in Java are:
 
 
 
 
Operator
 
Description
 
 
 
~
 
Bitwise Complement
 
 
 
 
Left Shift
 
 
 
>>
 
Right Shift
 
 
 
>>>
 
Unsigned Right Shift
 
 
 
&
 
Bitwise AND
 
 
 
^
 
Bitwise exclusive OR
 
 
 
 
These operators are not generally used in Java. To learn more, visit Java Bitwise and Bit Shift Operators.
 
Other operators
 
Besides these operators, there are other additional operators in Java.
 
Java instanceof Operator
 
The instanceof operator checks whether an object is an instanceof a particular class. For example,
 
Is str an object of String? true
 
Here, str is an instance of the String class. Hence, the instanceof operator returns true . To learn more, visit Java instanceof.
 
Java Ternary Operator
 
The ternary operator (conditional operator) is shorthand for the if-then-else statement. For example,
 
variable = Expression ? expression1 : expression2
 
 
If the Expression is true , expression1 is assigned to the variable .
 
If the Expression is false , expression2 is assigned to the variable .
 
 
Let's see an example of a ternary operator.
 
In the above example, we have used the ternary operator to check if the year is a leap year or not. To learn more, visit the Java ternary operator.
 
Now that you know about Java operators, it's time to know about the order in which operators are evaluated. To learn more, visit Java Operator Precedence.
 
Table of Contents
 
Источник
 
Operators
 
Now that you've learned how to declare and initialize variables, you probably want to know how to do something with them. Learning the operators of the Java programming language is a good place to start. Operators are special symbols that perform specific operations on one, two, or three operands, and then return a result.
 
As we explore the operators of the Java programming language, it may be helpful for you to know ahead of time which operators have the highest precedence. The operators in the following table are listed according to precedence order. The closer to the top of the table an operator appears, the higher its precedence. Operators with higher precedence are evaluated before operators with relatively lower precedence. Operators on the same line have equal precedence. When operators of equal precedence appear in the same expression, a rule must govern which is evaluated first. All binary operators except for the assignment operators are evaluated from left to right; assignment operators are evaluated right to left.
 
Operator Precedence
  
 
Operators
 
Precedence
 
 
 
postfix
 
expr++ expr--
 
 
 
unary
 
++expr --expr +expr -expr ~ !
 
 
 
multiplicative
 
* / %
 
 
 
additive
 
+ -
 
 
 
shift
 
> >>>
 
 
 
relational
 
 < >= instanceof
 
 
 
equality
 
== !=
 
 
 
bitwise AND
 
&
 
 
 
bitwise exclusive OR
 
^
 
 
 
bitwise inclusive OR
 
|
 
 
 
logical AND
 
&&
 
 
 
logical OR
 
||
 
 
 
ternary
 
? :
 
 
 
assignment
 
= += -= *= /= %= &= ^= |= <>= >>>=
 
 
 
 
In general-purpose programming, certain operators tend to appear more frequently than others; for example, the assignment operator " = " is far more common than the unsigned right shift operator " >>> ". With that in mind, the following discussion focuses first on the operators that you're most likely to use on a regular basis, and ends focusing on those that are less common. Each discussion is accompanied by sample code that you can compile and run. Studying its output will help reinforce what you've just learned.
 
Previous page: Questions and Exercises: Variables 
Next page: Assignment, Arithmetic, and Unary Operators
 
Источник
 
Assignment, Arithmetic, and Unary Operators
 
One of the most common operators that you'll encounter is the simple assignment operator " = ". You saw this operator in the Bicycle class; it assigns the value on its right to the operand on its left:
 
int cadence = 0; int speed = 0; int gear = 1;
 
This operator can also be used on objects to assign object references, as discussed in Creating Objects.
 
The Arithmetic Operators
 
The Java programming language provides operators that perform addition, subtraction, multiplication, and division. There's a good chance you'll recognize them by their counterparts in basic mathematics. The only symbol that might look new to you is " % ", which divides one operand by another and returns the remainder as its result.
 
 
 
Operator
 
Description
 
 
 
+
 
Additive operator (also used for String concatenation)
 
 
 
-
 
Subtraction operator
 
 
 
*
 
Multiplication operator
 
 
 
/
 
Division operator
 
 
 
%
 
Remainder operator
 
 
 
The following program, ArithmeticDemo , tests the arithmetic operators.
 
This program prints the following:
 
1 + 2 = 3 3 - 1 = 2 2 * 2 = 4 4 / 2 = 2 2 + 8 = 10 10 % 7 = 3
 
You can also combine the arithmetic operators with the simple assignment operator to create compound assignments. For example, x+=1; and x=x+1; both increment the value of x by 1.
 
The + operator can also be used for concatenating (joining) two strings together, as shown in the following ConcatDemo program:
 
By the end of this program, the variable thirdString contains "This is a concatenated string.", which gets printed to standard output.
 
The Unary Operators
 
The unary operators require only one operand; they perform various operations such as incrementing/decrementing a value by one, negating an expression, or inverting the value of a boolean.
 
 
 
Operator
 
Description
 
 
 
+
 
Unary plus operator; indicates positive value (numbers are positive without this, however)
 
 
 
-
 
Unary minus operator; negates an expression
 
 
 
++
 
Increment operator; increments a value by 1
 
 
 
--
 
Decrement operator; decrements a value by 1
 
 
 
!
 
Logical complement operator; inverts the value of a boolean
 
 
 
The following program, UnaryDemo , tests the unary operators:
 
The increment/decrement operators can be applied before (prefix) or after (postfix) the operand. The code result++; and ++result; will both end in result being incremented by one. The only difference is that the prefix version ( ++result ) evaluates to the incremented value, whereas the postfix version ( result++ ) evaluates to the original value. If you are just performing a simple increment/decrement, it doesn't really matter which version you choose. But if you use this operator in part of a larger expression, the one that you choose may make a significant difference.
 
The following program, PrePostDemo , illustrates the prefix/postfix unary increment operator:
 
Источник