operators
conditional
(ternary) operator
See also assignments
Operator

Usage 
Operation
Performed



Shift the bits of 


Shift the bits of 


Shift bits of 
■ You cannot use bit operators on Strings, objects, or Wrappers. Bit operators work only on expressions with integer types byte, short, int, long, and char. Plus some also apply to boolean. i.e.
( true  false ) returns false
■ The operator for the number of bits to be shifted can be any of the integer primitive types, including long and char.
■ The integer operand is always promoted to int before the shifting.
■ >> right shift, always propogates the sign bit (meaning it fills in the left side with whatever the sign was.)
Thus when you are using >> negative numbers always stay negative and positive numbers always stay positive.
■ >>> right shift zero fill always fills the left side with zeroes. So negative numbers will become positive.
■ << left shift zero fill always fills the right side with zeroes. Numbers can become variously positive or negative depending on whatever bit lands in the sign bit position.
■ Note that there is no <<< operator.
■ Also legal
are &=, =, ^=,
<<=, >>=,
and >>>= which combine assignments.
■ If you try to shift more than the number of bits in the variable's type (i.e. int >> 33) the actual number of bits shifted is: the requested length of the shift modulo the type's length. i.e.
int >> 35 would shift just 3 bits, because 35 % 32 is 3.
int >> 32 wouldn't shift any, because 32 % 32 is 0.
Note that byte >> 10 or (byte) byte >> 10 will both actually shift the 10 bits even though the byte type has only 8, because the operand is promoted to int first.
Operator 
Name 
Usage 
Returns true if 
&& 
Conditional AND 
op1 && op2 
op1 and op2 are
both true. Conditionally evaluates op2 if
necessary. 
 
Conditional OR 
op1  op2 
Either op1 or op2 is true.
Conditionally evaluates op2 if necessary. 
■ This is the only Java operator taking three
operands.
■ Its form is: a = b > c ? d : e; It means: If the first operand ( here b > c) is boolean true, then assign the second ( d ). Else assign the third ( e ).
■ The
variables b and c must either match a’s
type or be automatically promotable to it.
i.e. (assuming all Strings here)
greeting = (name == null) ?
"Hello" : "Hi " + name;
Operator 
Name 
Usage 
Returns true if 
! 
Negation 
! op1 
op1 is false. 
& 
AND 
op1 & op2 
Both op1 and op2 are true. Always evaluates both op1 and op2. 
 
OR 
op1  op2 
Either op1 or op2 is true. Always evaluates both op1 and op2. 
^ 
Exclusive OR 
op1 ^ op2 
op1 and op2 are different. Meaning one or the other of the operands is true, but not
both. 
■ & AND Here both bits must be on to make a 1. &= is legal.
■  OR Here both bits or either bit can be on to make a 1. = is legal.
■ ^ EXCLUSIVE OR (XOR) Here only either bit can be on to make a 1, not both. ^= is legal.
■ You can apply logical operators to boolean primitives. When doing so, true always acts like a one and false like a zero. i.e.
( true & false )
and ( false & false ) both return false
because both aren't on.
■ AND ( & ), OR (  ), and XOR ( ^ ) also work with doubleboolean expressions. You get a compile error if there are not two boolean operands present.
■ For AND ( & ), OR (  ), and XOR ( ^ ), both tests are always conducted, no matter what the outcome of the first test..
■ Legal are &=, =, and ^=.
■ % is called modulo, also known as modulus.
■ The result of modulo always takes the sign of the left operand, regardless of the sign of the quotient or right operand. i.e.
int x = 10;
int y = 3; or
int y = 3; In either case x % y equals –1.
So a % b is always negative only if a is negative. i.e. No matter what b is.
■ For the int type, a % b throws an ArithmeticException if b is zero. i.e. It uses the same exceptionthrowing rule as for dividing by zero in all integer types.
■ For floating points, a % b returns a NaN if b is zero.
Note that the integer dividingbyzero rule doesn’t apply to floating point types. Floating point division by zero always returns Infinity.
■ Postassignment operators ++ and   are fulfilled after the operator’s part of the overall expression, not at the end of their statement. i.e.
int x = 1;
int y = 2;
System.out.println( x + y++ + y); This will bump y immediately after adding y to x, so the bump will occur before the second use of y for the addition. 6 is printed here.
System.out.println( x++ ); Prints the old (existing) value of x, and then x is bumped prior to the start of the next statement.
int x = 1;
int y = x++; Will bump x after adding it to y, so y becomes 1 here.
Operator

Usage 
Returns true if



















shortcut operators
■ There are 12 shortcut assignment operators:
Operator

Is equivalent to doing this: 
























■ The && and  conditional (short circuit) operators don’t do the second test if it won’t affect the results of the first one.
i.e. The example below uses short circuit operators to
ensure having a nonnull String
in hand before actually testing it:
if (myString != null &&
myString.equalsIgnoreCase(“value”) ) {do something}
■ There’s no
short circuit for XOR. i.e. no ^^ exists
■ You can only
use boolean tests in short circuit operators.
■ There are no such things as “short circuit equals” operators like &&=, =, or ^^=.
■ The ~ (that's a tilde) unary complement operator flips all bits in the variable to which it is applied.
Its single operand is converted up to int if it is shorter than int. i.e.
byte b1 = 0;
System.out.print( ~ b1 );
byte b2 = b1; Prints 1 and b2 becomes 1.
byte b1 = 0;
byte b2 = (byte) ~ b1; Here b2 again becomes 1 or 1111 1111.
■ The unary complement of a positive integer is always the negative of the number, lowered one more. Meaning ~ x == (x) 1 i.e.
~ 21 =  22
Take 21,
consider it negative as 21, and then lower it one more
to 22.
■ The unary complement of a negative integer is always the positive of the number, lowered one more. i.e.
~ 21 = 20 Take 21,
consider it to be positive 21, then lower it one more to 20.
■ Note that ~= is illegal. There's no such shorthand operator. i.e.
y ~ = x; will not compile.