Operators

Mathematical operators
Integer division truncates, rather than rounds, the result.

If you create a Random object with no arguments, Java uses the current time as a seed for the random number generator, and will thus produce different output for each execution of the program.

Logical operators
Each of the logical operators AND (&&), OR (||) and NOT (!) produces a boolean value of true or false based on the logical relationship of its arguments.
When dealing with logical operators, you run into a phenomenon called “short-circuiting.” This means that the expression will be evaluated only until the truth or falsehood of the entire expression can be unambiguously determined. As a result, the latter parts of a logical expression might not be evaluated.

Literals
Ordinarily, when you insert a literal value into a program, the compiler knows exactly what type to make it. Sometimes, however, the type is ambiguous. When this happens, you must guide the compiler by adding some extra information in the form of characters associated with the literal value.

Hexadecimal (base 16), which works with all the integral data types, is denoted by a leading 0x or 0X followed by 0-9 or a-f either in uppercase or lowercase.
Octal (base is denoted by a leading zero in the number and digits from 0-7.

        int i1 = 0x2f; // Hexadecimal (lowercase)
        int i2 = 0X2F; // Hexadecimal (uppercase)   
        int i3 = 0177; // Octal (leading zero)
        char c = 0xffff; // max char hex value
        byte b = 0x7f; // max byte hex value
        short s = 0x7fff; // max short hex value

print("i1: " + Integer.toBinaryString(i1));
i1: 101111
i2: 101111
i3: 1111111
c: 1111111111111111
b: 1111111
s: 111111111111111

Notice in the preceding code the maximum possible hexadecimal values for char, byte, and short. If you exceed these, the compiler will automatically make the value an int and tell you that you need a narrowing cast for the assignment

Exponential notation
"e" means "10 to the power."
Uppercase and lowercase ‘e’ are the same:
   float expFloat = 1.39e-43f;
   System.out.println(expFloat);
    double expDouble = 47e47d; // ‘d’ is optional
    double expDouble2 = 47e47; // Automatically double
    System.out.println(expDouble);
/* Output:
    1.39E-43
    4.7E48

long n3 = 200;
there’s no ambiguity, so an L after the 200 would be superfluous. However, with float f4 = 1e-43f; // 10 to the power
the compiler normally takes exponential numbers as doubles, so without the trailing f, it will give you an error telling you that you must use a cast to convert double to float.

Bitwise operators
The bitwise operators allow you to manipulate individual bits in an integral primitive data type.
The bitwise AND operator (&) produces a one in the output bit if both input bits are one; otherwise, it produces a zero.
The bitwise OR operator (|) produces a one in the output bit if either input bit is a one and produces a zero only if both input bits are zero.
The bitwise EXCLUSIVE OR, or XOR (^), produces a one in the output bit if one or the other input bit is a one, but not both.
The bitwise NOT (~, also called the ones complement operator) is a unary operator; it takes only one argument. (All other bitwise operators are binary operators.) Bitwise NOT produces the opposite of the input bit—a one if the input bit is zero, a zero if the input bit is one.

Bitwise operators can be combined with the = sign to unite the operation and assignment: &=, |= and ^= are all legitimate. (Since ~ is a unary operator, it cannot be combined with the = sign.)

The boolean type is treated as a one-bit value, so it is somewhat different. You can perform a bitwise AND, OR, and XOR, but you can’t perform a bitwise NOT (presumably to prevent confusion with the logical NOT). For booleans, the bitwise operators have the same effect as the logical operators except that they do not short circuit.

Shift operators
The shift operators also manipulate bits. They can be used solely with primitive, integral types.
The left-shift operator (<<) produces the operand to the left of the operator after it has been shifted to the left by the number of bits specified to the right of the operator (inserting zeroes at the lower-order bits).
The signed right-shift operator (>>) produces the operand to the left of the operator after it has been shifted to the right by the number of bits specified to the right of the operator. The signed right shift >> uses sign extension: If the value is positive, zeroes are inserted at the higher-order bits; if the value is negative, ones are inserted at the higher-order bits.
Unsigned right shift >>>, which uses zero extension: Regardless of the sign, zeroes are inserted at the higher-order bits.

f you shift a char, byte, or short, it will be promoted to int before the shift takes place, and the result will be an int. Only the five low-order bits of the right-hand side will be used. This prevents you from shifting more than the number of bits in an int.
If you’re operating on a long, you’ll get a long result. Only the six low-order bits of the right-hand side will be used, so you can’t shift more than the number of bits in a long.

原码：
   在用二进制原码表示的数中，符号位为0表示正数，符号位为1表示负数，其余各位表示数值部分。如：10000010表示-2，00000010表示2。
反码：    
⑴对于正数，它的反码表示与原码相同
⑵对于负数，则除符号位仍为“1”外，其余各位“1”换成“0”，“0”换成“1”，即得到反码[X]反。例如[11101001]反=10010110。
⑶对于0，它的反码有两种表示:[+0]反=00…0  [-0]反=11…1
补码：
  正数的补码就是该正数本身。
  对于负数:符号位不变，反码加1。

Casting operators
Truncation and rounding
casting from a float or double to an integral value always truncates the number. If instead you want the result to be rounded, use the round( ) methods in java.lang.Math:

Java has no “sizeof”
In C and C++, the sizeof( ) operator tells you the number of bytes allocated for data items. The most compelling reason for sizeof( ) in C and C++ is for portability. Different data types might be different sizes on different machines.
Java does not need a sizeof( ) operator for this purpose, because all the data types are the same size on all machines.