Operators

Precedence of Java Operators
 
 
 

[ ]	( )
++	--	!	~
*	/	%
+	-	<<	>>	>>>
<	>	<=	>=
= =	!=
&
^
|
&&
||
?:
=	+=	…

 

 Associativity of Java Operators

almost all - from left to right
=  += ...     from right to left

Example:

z = p * r % q + w / x - y          ==>    z =((((p * r) % q) + (w / x)) - y)
   6    1    2     4    3    5

z = a + b + k * (c = d = 0)         ==>   z = ((a + b) +( k* ((c = (d = 0)) )))
   6    1    5    4     3    2

Data Types:

There are two data types available in Java −

• Primitive Data Types
• Reference/Object Data Types

Primitive Data Types

There are eight primitive datatypes supported by Java. Primitive datatypes are predefined by the language and named by a keyword. Let us now look into the eight primitive data types in detail.

byte

• Byte data type is an 8-bit signed two's complement integer

• Minimum value is -128 (-2^7)

• Maximum value is 127 (inclusive)(2^7 -1)

• Default value is 0

• Byte data type is used to save space in large arrays, mainly in place of integers, since a byte is four times smaller than an integer.

• 
  

short

• Short data type is a 16-bit signed two's complement integer

• Minimum value is -32,768 (-2^15)

• Maximum value is 32,767 (inclusive) (2^15 -1)

• Short data type can also be used to save memory as byte data type. A short is 2 times smaller than an integer

• Default value is 0.

• 
  

int

• Int data type is a 32-bit signed two's complement integer.

• Minimum value is - 2,147,483,648 (-2^31)

• Maximum value is 2,147,483,647(inclusive) (2^31 -1)

• Integer is generally used as the default data type for integral values unless there is a concern about memory.

• The default value is 0

• Example: int a = 100000, int b = -200000

long

• Long data type is a 64-bit signed two's complement integer
• Minimum value is -9,223,372,036,854,775,808(-2^63)
• Maximum value is 9,223,372,036,854,775,807 (inclusive)(2^63 -1)
• This type is used when a wider range than int is needed
• Default value is 0L
• Example: long a = 100000L, long b = -200000L

float

• Float data type is a single-precision 32-bit IEEE 754 floating point

• Float is mainly used to save memory in large arrays of floating point numbers

• Default value is 0.0f

• Float data type is never used for precise values such as currency

• Example: float f1 = 234.5f

double

• double data type is a double-precision 64-bit IEEE 754 floating point

• This data type is generally used as the default data type for decimal values, generally the default choice

• Double data type should never be used for precise values such as currency

• Default value is 0.0d

• Example: double d1 = 123.4

boolean

• boolean data type represents one bit of information
• There are only two possible values: true and false
• This data type is used for simple flags that track true/false conditions
• Default value is false
• Example: boolean one = true

char

• char data type is a single 16-bit Unicode character
• Minimum value is '\u0000' (or 0)
• Maximum value is '\uffff' (or 65,535 inclusive)
• Char data type is used to store any character
• Example: char letterA = 'A'

The type of the result of the operation is of the type of operands with one exception - if the type of the result must be byte or short it is converted to int. 

If the operands  are of a different type, a preliminary conversion of the type of operands is automatically performed in such a way that there is no loss of information. The arrows in the figure below shows the possible conversions.  The arrows with a dashed lines show possible loss of precision.

public class Oper {
    public static void main(String arg[]){
        int i1=4, i2 = 5;
        byte b=127,b1=1;
        double f1 =5.0;
        System.out.println("b:"+b+"\tb+b1:"+(b+b1)+"\t++b:"+ ++b);  // byte converted to int
        System.out.println("i1/i2:"+(i1/i2)+ "\ti1/f1:"+(i1/f1));               /* i1/i2 - without conversion - result 0
                                                                                                           i1/f1 - i1 is converted in double - result 0.8   */
    }
}

Explicit conversion (caste).

public class Oper {
    public static void main(String arg[]){
        int in;
        long ln=123L;
        double db = 34.5;
        in = ln;        //type mismatch
        in = db;        //type mismatch
        in = (int)ln;    //ok
        in = (int)db;    //ok
    }
}

Almost all operations can be used only with primitive types. Only the operations '=', '= =', and '! =' Can be used with all objects and the "String" class supports the operations '+' and '+ ='.

Featurs:

The '+' operator is used with String objects for concatenation. If an expression begins with a String object, all subsequent operands are converted to "String" (in recent versions, this conversion is performed even if the String object is not the first operand):

        int x = 0, y = 1, z = 2;
        String sString = "x, y, z ";
        System.out.println(sString + x + y + z);   //  x,y,z 012
        System.out.println(sString + (x + y + z));  //  x,y,z 3