Operators, Assignments, Comparisons

The test includes the operators that many of us may skip over.

• Bitwise (>>,<<,>>>)
• instanceof
• Object reference operators (+,+=,==,Object.equals(), and overridden equals() )

Notes.

• Follow the precedence chart.  In the same level, then left to right.
• Integers may throw an ArithmeticException.  Floating points (double & float) do not!
• Divide by 0 w/ Integers throws an ArithmeticException.
• Divide by 0 w/ Floating points = infinity

Examples

• Modulus: 10 % 10 = 0 (remainder)
• Modulus: 5 % 2 = 1  (remainder)
• Integer Division: 1 / 2 = 0  (no decimals)
• Floating point Division: 1 / 2.0 = .5
• Precedence: 2 + 2 * 3 = 8
  Precedence: (2 + 2) * 3 = 12
• int y = 0; int x = y++;  Results: y=1, x=0
  int y = 0; int x = ++y;  Results: y=1, x=1

• << - Bits shift to the left.
• >>> - Bits shift to the right (including the sign bit).
• >> - Bits shift to the right. Remember this saying: "Two right keep tight!"  This means that the high bit (sign indicator) stays set and it also moves to the right!  (see my web site source code examples).
• Bitwise shifting returns an int.  If you cast to a lower value you may loose bits.

Remember:

• Once a bit at the far left or far right and is shifted again, that bit is lost (goes to the bit bucket). 
  ex: If int = "0010 0011"
  int = int >> 1 , results = 0001 0001
  int = int << 1 , results = 0010 0010
  int = int >>> 1, results = 0001 0001
• With negatives the >> and >>> work differently.
  • intTest = -8
    11111111111111111111111111111000 = -8
  • intTest = intTest >> 1  (now -4)
    11111111111111111111111111111100 = -4
    Notice that the sign bit (far left) stays a 1.
  • intTest = intTest << 1  (back to -8)
    11111111111111111111111111111000 = -8
    Notice that the right bit sifts in as "0".
  • intTest = intTest >>> 1 
    01111111111111111111111111111100 = 2147483644
    Notice that the sign bit (far left) is "0".
    This is the difference in >> & >>>.
    >> - sign bit (far left bit) stays 1 if it was 1.
    >>> - sign bit (far left bit) is always 0.

Examples:

• int i = 0x00000021; int ans = 0; ans = i >>2;
  Results in base 10: i = 33 and ans =  8
  Results in base 2: i=0010 0001, ans=0000 1000

Rules

• If the first bit (sign bit) of an integer is 1, then the number is a negative.
• Steps to figure out the value of a 32 byte with the sign bit set.
  • Apply 2's compliment to the byte.  To do this you invert every bit.  All 1's become 0's and all 0's become 1's.
  • Add 1 to the byte.

Examples

Good luck.  This can be complicated.

• Data types must be boolean.  Results is boolean.
• All conditions are evaluated from left to right, even if the final result can be predicted.

Example:

• int y = 0;
  if (true | (y=5) == 5);
  results:  y = 5

Bitwise - AND/OR

• Data types must be integers.  Results is an integer.
• int Y = ( 1 | 2 );  Results Y = 3
  0001
  0010
  -----
  0011 = 3 base 10

Examples:

• (4 & 3) + (2 | 1) = 3 (in base 10)
  4 = 1000  2 = 0010
  3 = 0011  1 = 0001
  AND ----  OR  ----
      0000  +   0011 
      0     +      3  = 3 Base 10

• Data types must be boolean.  Results is a boolean.
• Conditions are evaluated from left to right, until the final result can be predicted.

Examples:

• int y = 0;
  if (true || (y=5) == 5);
  results:  y = 0

• is an instance of another object (subclassed, etc...)
• or implements an interface.

Notes:

• All objects are an instance of the Object class.
• All numeric wrappers are an instance of the Numeric class.
• All applets are an instance of the Applet class.
• Any class that implements an interface is an instance of that interface.
• Any class that is a subclass of a class is an instance of that class.

Examples:

• System.out.println( (new Integer(5)) instanceof Number) ); shows true - because all wrappers are extended from the Number class.
  

• True is returned if the two objects reside in the same memory location (the object references are equal).
• Two different objects may have identical data but will not be == because they reside in different memory locations.
• Identical object references can be in different variables.  The two variables may point to the same location.
• The method equals() in the Object class does the same thing as the ==.  Remember that all objects are instance of the Object class and inherit this method.
• WARNING - some classes override the equals() method and return true if the data value is equal.  (see equals() section below!)

• Unless this method is overridden by a class, it returns true if the objects reside in the same memory location.
• In other words, by default equals() and == do the same thing.

Value of an object  v.s. Object references - The equals() is overridden by the following classes to return true if the data value is equal! 

• String  (on the Test)
• all Wrappers (on the Test)
• Date - if date & time is equal.
• BitSet - same sequence of bits.
• File - if same relative path name.  Warning:  possibly maybe a different underlying file.

Example:

• Boolean b1 = new Boolean(true);
  Boolean b2 = new Boolean(true);
  System.out.println( "Test: "+ b1.equals( b2 ) );  = true
  System.out.println( "Test: "+ ( b1 == b2 ) );  = false

This is like an inline if statement.

Examples:

• System.out.println( (true ? "True choosen" : "False ") ) ; shows "True choosen"
• int X  = 5; int Y = 3; int Z = 0;
  Z = ( X > Y  ?  X + Y  :  0 );
  Results:  Z = 8

• ~ - reverse bits.  This will return the One's complement.
  Ex:  int i = 0x00000008; i = ~i;  Results i = 0xFFFFFF7
  Why:  Binary 0000 = 0 reverse bits to 1111 = F
  Why:  Binary 1000 = 8 reverse bits to 0111 = 7. 
  
• ^ - exclusive-or (XOR) - returns true if one is true and one is false.
  ( true ^ false ); Returns true!
  ( true ^ true ); Returns false!
  ( false ^ false ); Returns false!

Note:  Math.pow(double a, double b) - Returns the value of the first argument raised to the power of the second argument.  Some languages use the ^ for this, but not Java.