OPERATORS IN JAVA

OPERATORS IN JAVA

Java provides a rich set of operators to manipulate variables. They are

• Arithmetic Operators
• Relational Operators
• Bitwise Operators
• Logical Operators
• Assignment Operators
• Misc Operators

The Arithmetic Operators:

• Arithmetic Operators are used to perform some mathematical operations like addition, subtraction, multiplication, division, and modulo (or remainder).
• Arithmetic operators are used in mathematical expressions in the same way that they are used in algebra. The following table lists the arithmetic operators:
• Assume integer variable A holds 10 and variable B holds 20 then:

Examples

Operator	Description	Example
+	Addition - Adds values on either side of the operator	A + B will give 30
-	Subtraction - Subtracts right hand operand from left hand operand	A - B will give -10
*	Multiplication - Multiplies values on either side of the operator	A * B will give 200
/	Division - Divides left hand operand by right hand operand	B / A will give 2
%	Modulus - Divides left hand operand by right hand operand and returns remainder	B % A will give 0
++	Increment - Increase the value of operand by 1	B++ gives 21
--	Decrement - Decrease the value of operand by 1	B-- gives 19

The Relational Operators:

• Whenever we need to compare the results of two expressions or operands in a program then the equality and relational operators are used to know whether an operand is equal, not equal, greater than, less than to another operand.
• There are following relational operators supported by Java language
• Assume variable A holds 10 and variable B holds 20 then:

Examples

Operator	Description	Example
==	Checks if the value of two operands are equal or not, if yes then condition becomes true.	(A == B) is not true.
!=	Checks if the value of two operands are equal or not, if values are not equal then condition becomes true.	(A != B) is true.
>	Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true.	(A > B) is not true.
<	Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true.	(A < B) is true.
>=	Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true.	(A >= B) is not true.
<=	Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true.	(A <= B) is true.

The Bitwise Operators:

• Java defines several bitwise operators which can be applied to the integer types, long, int, short, char, and byte.
• In Java the bitwise and bit shift operators are used to manipulate the contents of variables at a bit level according to binary format.
• Bitwise operator works on bits and perform bit by bit operation. Assume if a = 60; and b = 13; 
• Now in binary format they will be as follows:

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

Assume integer variable A holds 60 and variable B holds 13 then:

Examples:

Operator	Description	Example
&	Binary AND Operator copies a bit to the result if it exists in both operands.	(A & B) will give 12 which is 0000 1100
|	Binary OR Operator copies a bit if it exists in eather operand.	(A | B) will give 61 which is 0011 1101
^	Binary XOR Operator copies the bit if it is set in one operand but not both.	(A ^ B) will give 49 which is 0011 0001
~	Binary Ones Complement Operator is unary and has the efect of 'flipping' bits.	(~A ) will give -60 which is 1100 0011
<<	Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand.	A << 2 will give 240 which is 1111 0000
>>	Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand.	A >> 2 will give 15 which is 1111
>>>	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 up with zeros.	A >>>2 will give 15 which is 0000 1111

The Logical Operators:

• Logical operators return a true or a false value based on the state of the variables i.e. the operations using conditional operators are performed between the two boolean expressions.
• The following table lists the logical operators:
• Assume boolean variables A holds true and variable B holds false then:

Examples:

Operator	Description	Example
&&	Called Logical AND operator. If both the operands are non zero then then condition becomes true.	(A && B) is false.
||	Called Logical OR Operator. If any of the two operands are non zero then then condition becomes true.	(A || B) is true.
!	Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false.	!(A && B) is true.

The Assignment Operators:

• Assignment operator is the most common operator almost used with all programming languages
• There are following assignment operators supported by Java language:

Examples:

Operator	Description	Example
=	Simple assignment operator, Assigns values from right side operands to left side operand	C = A + B will assigne value of A + B into C
+=	Add AND assignment operator, It adds right operand to the left operand and assign the result to left operand	C += A is equivalent to C = C + A
-=	Subtract AND assignment operator, It subtracts right operand from the left operand and assign the result to left operand	C -= A is equivalent to C = C - A
*=	Multiply AND assignment operator, It multiplies right operand with the left operand and assign the result to left operand	C *= A is equivalent to C = C * A
/=	Divide AND assignment operator, It divides left operand with the right operand and assign the result to left operand	C /= A is equivalent to C = C / A
%=	Modulus AND assignment operator, It takes modulus using two operands and assign the result to left operand	C %= A is equivalent to C = C % A
<<=	Left shift AND assignment operator	C <<= 2 is same as C = C << 2
>>=	Right shift AND assignment operator	C >>= 2 is same as C = C >> 2
&=	Bitwise AND assignment operator	C &= 2 is same as C = C & 2
^=	bitwise exclusive OR and assignment operator	C ^= 2 is same as C = C ^ 2
|=	bitwise inclusive OR and assignment operator	C |= 2 is same as C = C | 2

Misc Operators

There are few other operators supported by Java Language.

Conditional Operator ( ? : ):

• Conditional operator is also known as the ternary operator. This operator consists of three operands and is used to evaluate boolean expressions. 
• The goal of the operator is to decide which value should be assigned to the variable. The operator is written as :

variable x = (expression) ? value if true : value if false

Example:

public class Test {    public static void main(String args[]){       int a , b;       a = 10;       b = (a == 1) ? 20: 30;       System.out.println( "Value of b is : " +  b );       b = (a == 10) ? 20: 30;       System.out.println( "Value of b is : " + b );    } }

Output:

Value of b is : 30 Value of b is : 20

instanceOf Operator:

• Java provides a run-time operator instanceof to compare a class and an instance of that class. This operator " instanceof" compares an object to a specified class type.
• This operator is used only for object reference variables. The operator checks whether the object is of a particular type(class type or interface type). instanceOf operator is wriiten as:

( Object reference variable ) instanceOf  (class/interface type)

If the object referred by the variable on the left side of the operator passes the IS-A check for the class/interface type on the right side then the result will be true. 

Example:

String name = = 'James'; boolean result = s instanceOf String;  // This will return true since name is type of String

This operator will still return true if the object being compared is the assignment compatible with the type on the right. 

Example:

class Vehicle {} public class Car extends Vehicle {    public static void main(String args[]){       Vehicle a = new Car();       boolean result =  a instanceof Car;       System.out.println( result);    } }

Output:

true

Precedence of Java Operators:

• In Java, Operator Precedence is an evaluation order in which the operators within an expression are evaluated on the priority bases.
• Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others;

Unary Operators

• The unary operators requires only one operand to perform different kind of operations such as increasing/decreasing a value, negating an expression, or inverting a boolean value.
• Here operators with the highest precedence appear at the top of the table, those with the lowest appear at the bottom. Within an expression, higher precedenace operators will be evaluated first.

Category	Operator	Associativity
Postfix	() [] . (dot operator)	Left to right
Unary	++ - - ! ~	Right to left
Multiplicative	* / %	Left to right
Additive	+ -	Left to right
Shift	>> >>> <<	Left to right
Relational	> >= < <=	Left to right
Equality	== !=	Left to right
Bitwise AND	&	Left to right
Bitwise XOR	^	Left to right
Bitwise OR	|	Left to right
Logical AND	&&	Left to right
Logical OR	||	Left to right
Conditional	?:	Right to left
Assignment	= += -= *= /= %= >>= <<= &= ^= |=	Right to left
Comma	,	Left to right

CHARACTER EXTRACTION

CHARACTER EXTRACTION

• The String class provides a number of ways in which characters can be extracted from a String object. Although the characters that comprise a string within a String object cannot be indexed as if they were a character array, many of the String methods employ an index (or offset) into the string for their operation. 
• Like arrays, the string indexes begin at zero.

charAt( )

• To extract a single character from a String,  charAt( ) method is used. It has this general form:

           char charAt(int where)

Here, where is the index of the character that you want to obtain. The value of where must be nonnegative and specify a location within the string. charAt( ) returns the character at the specified location. 

Example:

char ch;

ch = "abc".charAt(1);

assigns the value “b” to ch.

getChars( )

• To extract more than one character at a time, use the getChars( ) method. It has this general form:

void getChars(int sourceStart, int sourceEnd, char target[ ], int targetStart)

• Here, sourceStart specifies the index of the beginning of the substring, and sourceEnd specifies an index that is one past the end of the desired substring. Thus, the substring contains the characters from sourceStart through sourceEnd–1. The array that will receive the characters is specified by target.  
• The index within target at which the substring will be copied is passed in targetStart. Care must be taken to assure that the target array is large enough to hold the number of characters in the specified substring.

Example:

class getCharsDemo {

public static void main(String args[]) {

String s = "This is a demo of the getChars method.";

int start = 10;

int end = 14;

char buf[] = new char[end - start];

s.getChars(start, end, buf, 0);

System.out.println(buf);

}

}

Output:

demo

getBytes( )

• There is an alternative to getChars( ) that stores the characters in an array of bytes. 
• This method is called getBytes( ), and it uses the default character-to-byte conversions provided by the platform. 

Here is its simplest form:

byte[ ] getBytes( ) Other forms of getBytes( ) are also available. getBytes( ) is most useful when you are exporting a String value into an environment that does not support 16-bit Unicode characters. For example, most Internet protocols and text file formats use 8-bit ASCII for all text interchange.

toCharArray( )

• To convert all the characters in a String object into a character array, the easiest way is to call toCharArray( ). 
• It returns an array of characters for the entire string. It has this general form:

char[ ] toCharArray( )

This function is provided as a convenience, since it is possible to use getChars( ) to achieve the same result.

SPECIAL STRING OPERATIONS INJAVA

SPECIAL STRING OPERATIONS

• Strings are a common and important part of programming, Java has added special support for several string operations within the syntax of the language.
•  These operations include the automatic creation of new String instances from string literals, concatenation of multiple String objects by use of the + operator, and the conversion of other data types to a string representation.
•  There are explicit methods available to perform all of these functions, but Java does them automatically as a convenience for the programmer and to add clarity.

String Literals

• A String instance from an array of characters by using the new operator. However, there is an easier way to do this using a string literal.
• Java automatically constructs a String object. Thus, you can use a string literal to initialize a Stringobject.

Example:

char chars[] = { 'a', 'b', 'c' };

String s1 = new String(chars);

String s2 = "abc"; // use string literal

A String object is created for every string literal, you can use a string literal any place you can use a Stringobject. For example, you can call methods directly on a quoted string as if it were an object reference, as the following statement shows. It calls the length( ) method on the string “abc”.As expected, it prints “3”.

System.out.println("abc".length());

IBRARY

String Concatenation

• Java does not allow operators to be applied to String objects. The one exception to this rule is the + operator, which concatenates two strings, producing a String object as the result. This allows you to chain together a series of + operations.

Example:

String age = "9";

String s = "He is " + age + " years old.";

System.out.println(s);

Output:

“He is 9 years old.”

One practical use of string concatenation is found when you are creating very long strings. Instead of letting long strings wrap around within your source code, you can break them into smaller pieces, using the + to concatenate them.

Example:

class ConCat {

public static void main(String args[]) {

String longStr = "This could have been " +

"a very long line that would have " +

"wrapped around. But string concatenation " +

"prevents this.";

System.out.println(longStr);

}

}

String Concatenation with Other Data Types

• It is possible to concatenate strings with other types of data.

int age = 9;

String s = "He is " + age + " years old.";

System.out.println(s);

Here age is an int rather than another String, but the output produced is the same as before. This is because the int value in age is automatically converted into its string representation within a String object. This string is then concatenated as before. The compiler will convert an operand to its string equivalent whenever the other operand of the + is an instance of String.

Example:

String s = "four: " + 2 + 2;

System.out.println(s);

Output:

four: 22

rather than the

four: 4

Operator precedence causes the concatenation of “four” with the string equivalent of 2 to take place first. This result is then concatenated with the string equivalent of 2 a second time. To complete the integer addition first, you must use parentheses, like this:

String s = "four: " + (2 + 2);

Now s contains the string “four: 4”.

String Conversion and toString( ) 

• When Java converts data into its string representation during concatenation, it does so by calling one of the overloaded versions of the string conversion method valueOf( ) defined by String. valueOf( ) is overloaded for all the simple types and for type Object.
•  valueOf( ) returns a string that contains the human-readable equivalent of the value with which it is called. For objects, valueOf( ) calls the toString( ) method on the object. 
• Every class implements toString( ) because it is defined by Object. However, the default implementation of toString( ) is seldom sufficient. For most important classes that you create, you will want to override toString( ) and provide your own string representations.

String toString( )

• To implement toString( ), simply return a Stringobject that contains the humanreadable string that appropriately describes an object of your class.
• By overriding toString( ) for classes that you create, you allow them to be fully integrated into Java’s programming environment. For example, they can be used in print( ) and println( ) statements and in concatenation expressions.
• The following program demonstrates this by overriding toString( ) for the Box class:

class Box {

double width;

double height;

double depth;

Box(double w, double h, double d) {

width = w;

height = h;

depth = d;

}

public String toString() {

return "Dimensions are " + width + " by " +

depth + " by " + height + ".";

}

}

class toStringDemo {

public static void main(String args[]) {

Box b = new Box(10, 12, 14);

String s = "Box b: " + b; // concatenate Box object

System.out.println(b); // convert Box to string

System.out.println(s);

}

}

Output:

Dimensions are 10.0 by 14.0 by 12.0

Box b: Dimensions are 10.0 by 14.0 by 12.0

 Box’s toString( ) method is automatically invoked when a Box object is used in a concatenation expression or in a call to println( )

HE JAVA LIBRARY