# Java Operators

##### Operator

Operator is a symbol which are used to perform particular operation. In java language these opeatrs are classified into following types.
1. Unary Operators
2. Binary Operators
3. Ternary Operators

##### Unary Operator:

If any operation perform on single operand (Variable) is known as uanry operator.
These operators are classified into following types.
1. Unary Minus Operator
2. Increment Operator
3. Decrement Operator

##### 1.Unary Minus:

Unary minus means sign value or minus value
Example:
int x=10;
then -x=-10;

Program
public class Main
{
public static void main(String args[])
{
int x=10;
System.out.println("The Sign value is "+(-x));
}
}

###### Output:
The Sign value is -10
public class Main
{
public static void main(String args[])
{
int x;
x=Integer.parseInt(args[0]);
System.out.println("The Sign value is "+(-x));
}
}

###### Output:
The Sign value is -10
import java.util.*;
public class Main
{
public static void main(String args[])
{
int x;
Scanner s=new Scanner(System.in);
System.out.println("Enter x Value");
x=s.nextInt();
System.out.println("The Sign value is "+(-x));
}
}

###### Output:
Enter x Value
The Sign value is -10
##### Increment Operator:

Increment Operator is used to increment the one value to the current value. These are classified into following types.
1.PreIncrement operator
2.PostIncrement operator

##### PreIncrement Operator(++x):

PreIncrement oprator is used to increment the value first assign the value later.
Example:
int x=10;
then ++x=11;

Program
public class Main
{
public static void main(String args[])
{
int x=10;
System.out.println("The PreIncrement value is "+(++x));
}
}

###### Output:
The PreIncrement value is 11
public class Main
{
public static void main(String args[])
{
int x;
x=Integer.parseInt(args[0]);
System.out.println("The PreIncrement value is "+(++x));
}
}

###### Output:
The PreIncrement value is 11
import java.util.*;
public class Main
{
public static void main(String args[])
{
int x;
Scanner s=new Scanner(System.in);
System.out.println("Enter x Value");
x=s.nextInt();
System.out.println("The PreIncrement value is "+(++x));
}
}

###### Output:
Enter x Value
The PreIncrement value is 11
##### Post Increment Operator:
PostIncrement Operator(x++):

In the post incrementation assign the value first increment the value later.
Example:
int x=10;
then x++=10;

Program
public class Main
{
public static void main(String args[])
{
int x=10;
System.out.println("The PostIncrement value is "+(x++));
}
}

###### Output:
The PostIncrement value is 10
public class Main
{
public static void main(String args[])
{
int x;
x=Integer.parseInt(args[0]);
System.out.println("The PostIncrement value is "+(x++));
}
}

###### Output:
The PostIncrement value is 10
import java.util.*;
public class Main
{
public static void main(String args[])
{
int x;
Scanner s=new Scanner(System.in);
System.out.println("Enter x Value");
x=s.nextInt();
System.out.println("The PostIncrement value is "+(x++));
}
}

###### Output:
Enter x Value
The PostIncrement value is 10
##### Decrement Operator:

Decrement Operator is used to decrement the one value to the current value. These are classified into following types.
1.PreDecrement operator
2.PostDecrement operator

PreDecrement Operator(--x):
PreDecrement oprator is used to Decrement the value first assign the value later.
Example:
int x=10;
then --x=9;

Program
public class Main
{
public static void main(String args[])
{
int x=10;
System.out.println("The PreDecrement value is "+(--x));
}
}

###### Output:
The PreDecrement value is 9
public class Main
{
public static void main(String args[])
{
int x;
x=Integer.parseInt(args[0]);
System.out.println("The PreDecrement value is "+(--x));
}
}

###### Output:
The PreDecrement value is 9
import java.util.*;
public class Main
{
public static void main(String args[])
{
int x;
Scanner s=new Scanner(System.in);
System.out.println("Enter x Value");
x=s.nextInt();
System.out.println("The PreDecrement value is "+(--x));
}
}

###### Output:
Enter x Value
The PreDecrement value is 9
##### Post Decrement Operator:
PostDecrement Operator(x--):

In the post Decrement assign the value first decrement the value later.
Example:
int x=10;
then x--=10;

Program
public class Main
{
public static void main(String args[])
{
int x=10;
System.out.println("The PostDecrementvalue is "+(x--));
}
}

###### Output:
The PostDecrement value is 10
public class Main
{
public static void main(String args[])
{
int x;
x=Integer.parseInt(args[0]);
System.out.println("The PostDecrement value is "+(x--));
}
}

###### Output:
The PostDecrement value is 10
import java.util.*;
public class Main
{
public static void main(String args[])
{
int x;
Scanner s=new Scanner(System.in);
System.out.println("Enter x Value");
x=s.nextInt();
System.out.println("The PostDecrement value is "+(x--);
}
}

###### Output:
Enter x Value
The PostDecrement value is 10

## Binary Operators

##### Binary Operator:

If any operation perform on two operands(variable) is known as binary operators.
In java language these opeatrs are classified into following types.
1.Arithmetic Operators
2.Assignment Operators
3.Relational Operators
4.Logical Operators
5.Bitwise Operators

### Key Points

##### Arithmetic Operators

These are the operands can be used to perform simple mathametical operation. Which are classified into following types.

Operator Operation Example Program
- Substraction x-y Program
* Multiplication x*y Program
/ Division x/y Program
% Modular Division x%y Program
public class Main
{
public static void main(String args[])
{
int x=10,y=20,z;
z=x+y;
}
}

##### Addition Of Two Numbers Using Commandline Arguments
public class Main
{
public static void main(String args[])
{
int x,y,z;
x=Integer.parseInt(args[0]);
y=Integer.parseInt(args[1]);
z=x+y;
}
}

##### Addition Of Two Numbers Using Scanner
import java.util.*;
public class Main
{
public static void main(String args[])
{
int x,y,z;
Scanner s=new Scanner(System.in);
System.out.println("Enter x,y values");
x=s.nextInt();
y=s.nextInt();
z=x+y;
}
}

##### Assignment Operators

Assignment operators are used to assign the values to the variable or assign the variable to variable
There are classified into following types.

Operator Example Same As
= x=y x=y
+= x+=y x=x+y
-= x-=y x=x-y
*= x*=y x=x*y
/= x/=y x=x/y
%= x%=y x=x%y
Write a java-program to print swaping of two numbers with using third variable

Write a Java-program to print swaping of two numbers without using third variable
##### Swaping Of Two Numbers With Using Third Variable
public class Main
{
public static void main(String args[])
{
int x=10,y=20,z;
z=x;
x=y;
y=z;
System.out.println("x value is: "+(x));
System.out.println("y value is: "+(y));
}
}

x value is: 20
y value is: 10
##### Swaping Of Two Numbers Using Commandline Arguments
public class Main
{
public static void main(String args[])
{
int x,y,z;
x=Integer.parseInt(args[0]);
y=Integer.parseInt(args[1]);
z=x;
x=y;
y=z;
System.out.println("x value is: "+(x));
System.out.println("y value is: "+(y));
}
}

x value is: 20
y value is: 10
##### Swaping Of Two Numbers Using Scanner
import java.util.*;
public class Main
{
public static void main(String args[])
{
int x,y,z;
Scanner s=new Scanner(System.in);
System.out.println("ENter x,y values");
x=s.nextInt();
y=s.nextInt();
z=x;
x=y;
y=z;
System.out.println("x value is: "+(x));
System.out.println("y value is: "+(y));
}
}

x value is: 20
y value is: 10
##### Swaping Of Two Numbers Without Using Third Variable
public class Main
{
public static void main(String args[])
{
int x=10,y=20;
x=x+y;
y=x-y;
x=x-y;
System.out.println("x value is: "+(x));
System.out.println("y value is: "+(y));
}
}

x value is: 20
y value is: 10
##### Swaping Of Two Numbers Using Commandline Arguments
public class Main
{
public static void main(String args[])
{
int x,y,z;
x=Integer.parseInt(args[0]);
y=Integer.parseInt(args[1]);
x=x+y;
y=x-y;
x=x-y;
System.out.println("x value is: "+(x));
System.out.println("y value is: "+(y));
}
}

x value is: 20
y value is: 10
##### Swaping Of Two Numbers Using Scanner
import java.util.*;
public class Main
{
public static void main(String args[])
{
int x,y,z;
Scanner s=new Scanner(System.in);
System.out.println("Enter x,y values");
x=s.nextInt();
y=s.nextInt();
x=x+y;
y=x-y;
x=x-y;
System.out.println("x value is: "+(x));
System.out.println("y value is: "+(y));
}
}

x value is: 20
y value is: 10
##### Relational Operators

Relational operators are used to check the relation between two variables. These are classified into following types

Operator Example
== x==y
< x<y
> x>y
<= x<=y
>= x>=y
!= x!=y
Write a java-program to print relation of two numbers
##### Relation Of Two Numbers
public class Main
{
public static void main(String args[])
{
int x=10,y=20;
boolean z;
z=x>y;
System.out.println("z value is: "+(z));
}
}

###### Output:
z value is: false
##### Relation Of Two Numbers Using Commandline Arguments
public class Main
{
public static void main(String args[])
{
int x,y;
boolean z;
x=Integer.parseInt(args[0]);
y=Integer.parseInt(args[1]);
z=x>y;
System.out.println("z value is: "+(z));
}
}

###### Output:
z value is: false
##### Relation Of Two Numbers Using Scanner
import java.util.*;
public class Main
{
public static void main(String args[])
{
int x,y;
boolean z;
Scanner s=new Scanner(System.in);
System.out.println("Enter x,y values");
x=s.nextInt();
y=s.nextInt();
z=x>y;
System.out.println("z value is: "+(z));
}
}

###### Output:
z value is: false
##### Logical Operators

Logical Operators are used to combine the morethan one condition. These are classified into following types.

Operator Example
&& x>y && x>z
|| x>y || x>z
! !(x>y && x>z)

!(x>y || x>z)

!(x>y) && !(x>z)

!(x>y) || !(x>z)
Write a Java-program to print logical operators program using &&, || ,!
##### Logical Operators
public class Main
{
public static void main(String args[])
{
int x=10,y=20,z=30;
boolean p;
p=x>y && x>z;
System.out.println("p value is: "+(p));
}
}

###### Output:
p value is: false
##### Logical Operators Using Commandline Arguments
public class Main
{
public static void main(String args[])
{
int x,y,z;
boolean p;
x=Integer.parseInt(args[0]);
y=Integer.parseInt(args[1]);
z=Integer.parseInt(args[2]);
p=x>y && x>z;
System.out.println("p value is: "+(p));
}
}

###### Output:
p value is: false
##### Logical Operators Using Scanner
import java.util.*;
class Main
{
public static void main(String args[])
{
int x,y,z;
boolean p;
Scanner s=new Scanner(System.in);
System.out.println("Enter x,y,z values");
x=s.nextInt();
y=s.nextInt();
z=s.nextInt();
p=x>y && x>z;
System.out.println("p value is: "+(p));
}
}

###### Output:
p value is: false
##### Bitwise Operators

Bitwise Operators are used to perform any operaion on binary(0 and 1) values.These are classified into following types

Operator Operation Example Program
& AND x & y Program
| OR x|y Program
^ CAP x ^ y Program
~ NAGETION ~x Program
<< LEFT SHIFT x<<y Program
>> RIGHT SHIFT x>>y Program
##### Bitwise and(&) Operator
public class Main
{
public static void main(String args[])
{
int x=10,y=15,z
z=x & y;
System.out.println("z value is: "+(z));
}
}

z value is: 10
##### Bitwise and(&) Operator Using Commandline Arguments
public class Main
{
public static void main(String args[])
{
int x,y,z;
x=Integer.parseInt(args[0]);
y=Integer.parseInt(args[1]);
z=x & y;
System.out.println("z value is: "+(z));
}
}

z value is: 10
##### Bitwise and(&) Operators Using Scanner
import java.util.*;
public class Main
{
public static void main(String args[])
{
int x,y,z;
Scanner s=new Scanner(System.in);
System.out.println("Enter x,y values");
x=s.nextInt();
y=s.nextInt();
z=x & y;
System.out.println("z value is: "+(z));
}
}

z value is: 10
##### Conditional or Ternary Operator (?:)

Ternary operator is used to perform any operation on three operands

Syntax :

Expression1 ? Expression2 : Expression3;

Here
Expression1 is a condition
Expression2 is a operation
Expression3 is a operation

In the above syntax
if condition is true ,The statements of Expression2 is execute.
if condition is false ,The statements of Expression3 is execute

##### Odd or Even Number Using Ternary Operator
public class Main
{
public static void main(String args[])
{
int x=10;
String s = x%2==0 ? "Even Number" : "Odd Number";
System.out.println(s);
}
}

Even Number
##### Odd or Even Number Using Ternary Operator and Commandline Arguments
public class Main
{
public static void main(String args[])
{
int x;
x=Integer.parseInt(args[0]);
String s;
s= x%2==0 ? "Even Number" : "Odd Number";
System.out.println(s);
}
}

Even Number
##### Odd or Even Number Using Ternary Operator and Scanner
import java.util.*;
public class Main
{
public static void main(String args[])
{
int x;
Scanner s1=new Scanner(System.in);
System.out.println("Enter x value");
x=s1.nextInt();
String s;
s= x%2==0 ? "Even Number" : "Odd Number";
System.out.println(s);
}
}

Even Number
##### Max Number Using Ternary Operator

class Main
{
public static void main(String args[])
{
int x=10,y=20;
String s;
s= x>y ? "x is Max Number" : "y is Max Number";
System.out.println(s);
}
}

y is Max Number
##### Max Number Using Ternary Operator and Commandline Arguments

public class Main
{
public static void main(String args[])
{
int x,y;
x=Integer.parseInt(args[0]);
y=Integer.parseInt(args[1]);
String s;
s= x>y ? "x is Max Number" : "y is Max Number";
System.out.println(s);
}
}

Enter x ,y value
10
20
y is Max Number
##### Max Number Using Ternary Operator and Scanner
import java.util.*;
public class Main
{
public static void main(String args[])
{
int x,y;
Scanner s1=new Scanner(System.in);
System.out.println("Enter x ,y value");
x=s1.nextInt();
y=s1.nextInt();
String s;
s= x>y ? "x is Max Number" : "y is Max Number";
System.out.println(s);
}
}

Enter x ,y value
10
20
y is Max Number
##### MAX Number Amoung 3 Numbers

public class Main
{
public static void main(String args[])
{
int x=10,y=20,z=30
String s;
s=(x > y) ?(x > z ? "x is Max" : "z is Max") :(y > z ? "y is Max" : "z is Max");
System.out.println(s);
}
}

z is Max
##### MAX Number Amoung 3 Numbers Using Ternary Operator and Commandline Arguments

public class Main
{
public static void main(String args[])
{
int x,y,z;
x=Integer.parseInt(args[0]);
y=Integer.parseInt(args[1]);
z=Integer.parseInt(args[2]);
String s;
s=(x > y) ?(x > z ? "x is Max" : "z is Max") :(y > z ? "y is Max" : "z is Max");
System.out.println(s); } }
Enter x ,y value
10
20
z is Max
##### MAX Number Amoung 3 Numbers Using Ternary Operator and Scanner

import java.util.*;
public class Main
{
public static void main(String args[])
{
int x,y,z;
Scanner s1=new Scanner(System.in);
System.out.println("Enter x ,y ,z value");
x=s1.nextInt();
y=s1.nextInt();
z=s1.nextInt();

String s;

s=(x > y) ?(x > z ? "x is Max" : "z is Max") :(y > z ? "y is Max" : "z is Max");
System.out.println(s);
}
}

Enter x ,y value
10
20
30
z is Max

##### Simple Interest Program
public class Main
{
public static void main(String args[])
{
int a=2000,d=2,i=2,si;
si= (a*d*i)/100;
System.out.println("Simple Interest is: "+(si));
}
}

###### Output:
Simple Interest is: 80
##### Simple Interest Program Using Commandline Arguments
public class Main
{
public static void main(String args[])
{
int a,d,i,si;
a=Integer.parseInt(args[0]);
d=Integer.parseInt(args[1]);
i=Integer.parseInt(args[2]);
si= (a*d*i)/100;
System.out.println("Simple Interest is: "+(si));
}
}

###### Output:
Simple Interest is: 80
##### Simple Interest Program Using Scanner
import java.util.*;
public class Main
{
public static void main(String args[])
{
int a,d,i,si;
Scanner s=new Scanner(System.in);
System.out.println("Enter Amount:");
a=s.nextInt();
System.out.println("Enter Duration:");
d=s.nextInt();
System.out.println("Enter Interest:");
i=s.nextInt();
si= (a*d*i)/100;
System.out.println("Simple Interest is: "+(si));
}
}

###### Output:
Enter Amount:
2000
Enter Duration:
2
Enter Interest:
2
Simple Interest is: 80