Operators

August 6, 2009

Operators - 4 groups
arithmetic bitwise relational logical

additional operators that handle certain special situations

August 6, 2009

Arithmetic Operators

August 6, 2009

Arithmetic Operators
the operands must be of numeric type can also be of type char

August 6, 2009

class BasicMath { public static void main(String args[]) { // arithmetic using integers System.out.println("Integer Arithmetic"); int a = 1 + 1; int b = a * 3; int c = b / 4; int d = c - a; int e = -d; System.out.println("a = " + a); System.out.println("b = " + b); System.out.println("c = " + c); System.out.println("d = " + d); System.out.println("e = " + e); // arithmetic using doubles
August 6, 2009 5

System.out.println("\nFloating Point Arithmetic"); double da = 1 + 1; double db = da * 3; double dc = db / 4; double dd = dc - a; double de = -dd; System.out.println("da = " + da); System.out.println("db = " + db); System.out.println("dc = " + dc); System.out.println("dd = " + dd); System.out.println("de = " + de); } }
August 6, 2009 6

 The modulus operator, %, returns the remainder of a division operation It can be applied to floating-point types as well as integer types This differs from C/C++, in which the % can only be applied to integer types

August 6, 2009

class Modulus { public static void main(String args[]) { int x = 42; double y = 42.25; System.out.println("x mod 10 = " + x % 10); System.out.println("y mod 10 = " + y % 10); } } When you run this program you will get the following output: x mod 10 = 2 y mod 10 = 2.25

August 6, 2009

Arithmetic Compound Assignment Operators

a = a + 4; a += 4; Any statement of the form var = var op expression; can be rewritten as var op= expression; Implemented more efficiently by the Java run-time system than are their equivalent long forms
August 6, 2009 9

Increment and Decrement Operators

prefix postfix

August 6, 2009

10

The Bitwise Operators

August 6, 2009

11

August 6, 2009

12

The Bitwise Operators

can be applied to integer types long, int, short, char and byte

August 6, 2009

13

The Bitwise Logical Operators

August 6, 2009

14

class BitLogic { public static void main(String args[]) { String binary[ ] = { "0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111 }; int a = 3; // 0 + 2 + 1 or 0011 in binary int b = 6; // 4 + 2 + 0 or 0110 in binary int c = a | b; int d = a & b; int e = a ^ b; int f = (~a & b) | (a & ~b); int g = ~a & 0x0f; System.out.println(" a = " + binary[a]); System.out.println(" b = " + binary[b]); System.out.println(" a|b = " + binary[c]); System.out.println(" a&b = " + binary[d]);
August 6, 2009 15

System.out.println(" a^b = " + binary[e]); System.out.println("~a&b|a&~b = " + binary[f]); System.out.println(" ~a = " + binary[g]); } } Output of the program : a = 0011 b = 0110 a | b = 0111 a & b= 0010 a ^ b = 0101 ~a&B | a&~b = 0101 ~a = 1100
August 6, 2009 16

The Left Shift

It has this general form: value << num If you left-shift a byte value, that value will first be promoted to int and then shifted Also, a negative value will be sign extended This means that you must discard the top three bytes of the result if what you want is the result of a shifted byte value The easiest way to do this is to simply cast the result back into a byte
17

August 6, 2009

class ByteShift { public static void main(String args[]) { byte a = 64, b; int i; i = a << 2; b = (byte) (a << 2); System.out.println("Original value of a: " + a); System.out.println("i and b: " + i + " " + b); } }

August 6, 2009

18

Output: Original value of a: 64 i and b: 256 0

August 6, 2009

19

The Right Shift

The right shift operator, >>, shifts all of the bits in a value to the right a specified number of times value >> num

int a = 32; a = a >> 2; // a now contains 8 int a = 35; a = a >> 2; // a still contains 8
August 6, 2009 20

11111000 8 >>1 11111100 4 Sign extension :- when you are shifting right, the left most bits exposed by the right shift are filled in with the contents of the top bit. If you shift -1, the result always remains -1. In the program, the right shifted value is masked by ANDing it with 0x0f to discard the sign extended bits so that the value can be used an index in to the array of hexadecimal characters.

August 6, 2009

21

// Masking sign extension. class HexByte { static public void main(String args[]) { char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f }; byte b = (byte) 0xf1; System.out.println ("b = 0x" + hex[(b >> 4) & 0x0f] + hex[b & 0x0f]); } } // output: b = oxf1
August 6, 2009 22

The Unsigned Right Shift

Unsigned, shift-right operator, >>>, which always shifts zeros into the high-order bit int a = -1; a = a >>> 24; Here is the same operation in binary form to further illustrate what is happening: 11111111 11111111 11111111 11111111 1 in binary as an int >>>24 00000000 00000000 00000000 11111111 255 in binary as an int

August 6, 2009

23

>>> is only meaningful for 32 and 64 bit values. This is because smaller values are automatically promoted to int in expressions sign-extension occurs and the shift will take place on a 32 bit rather than on a 8 or 16 bit values

August 6, 2009

24

class ByteUShift { static public void main(String args[]) { char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f}; byte b = (byte) 0xf1; byte c = (byte) (b >> 4); byte d = (byte) (b >>> 4); byte e = (byte) ((b & 0xff) >> 4);

System.out.println(b = 0x + hex[(b >> 4) & 0x0f] + hex[b & 0x0f]); System.out.println(c = 0x + hex[(c >> 4) & 0x0f] + hex[c & 0x0f]); System.out.println(d = 0x + hex[(d >> 4) & 0x0f] + hex[d & 0x0f]); System.out.println(e = 0x + hex[(e >> 4) & 0x0f] + hex[e & 0x0f]); } August } 6, 2009
25

Output: b = 0xf1 b >> 4 = 0xff b >>> 4 = 0xff (b & 0xff) >> 4 = 0x0f

August 6, 2009

26

Bitwise Operator Compound Assignments

a = a >> 4; a >>= 4; a = a | b; a |= b;

August 6, 2009

27

Relational Operators

August 6, 2009

28

int a = 4; int b = 1; boolean c = a < b; int done; // ... if(!done) ... // Valid in C/C++ if(done) ... // but not in Java. In Java, these statements must be written like this: if(done == 0)) ... // This is Java-style. if(done != 0) ...

August 6, 2009

29

Java does not define true and false in the same way as C/C++ In Java, true and false are nonnumeric values which do not relate to zero or nonzero

August 6, 2009

30

Boolean Logical Operators

August 6, 2009

31

August 6, 2009

32

Short-Circuit Logical Operators

Java will not bother to evaluate the right-hand operand when the outcome of the expression can be determined by the left operand alone Example : if (denom != 0 && num / denom > 10) It is standard practice to use short-circuit forms for Boolean logic, leaving the single-character versions exclusively for bitwise operations. Exception to the above rule Example : if(c==1 & e++ < 100) d = 100;

August 6, 2009

33

The Assignment Operator

var = expression;
type of var must be compatible with the type of expression

int x, y, z; x = y = z = 100; // set x, y, and z to 100

August 6, 2009

34

The ? Operator
expression1 ? expression2 : expression3 Example: ratio = denom == 0 ? 0 : num / denom;

August 6, 2009

35

Operator Precedence

August 6, 2009

36

Using Parentheses
Parentheses raise the precedence of the operators that are inside them Parentheses (redundant or not) do not degrade the performance of your program Therefore, adding parentheses to reduce ambiguity does not negatively affect your program

August 6, 2009

37