Java Basic Data Types and Their Operations
1. Integer operations
 Four Operations
For integer types, Java only defines signed integers, so the bit of the highest bit represents the symbol bit (0 is positive, 1 is negative).The maximum range that each integer can represent is as follows:
 byte: 128 ~ 127
 short: 32768 ~ 32767
 int: 2147483648 ~ 2147483647

long: 9223372036854775808 ~ 9223372036854775807
Therefore, there is an overflow situation. To solve the overflow situation, only the specific number needs to be converted to binary to add or subtract. If the highest bit becomes 1, the number after overflow will become negative again.
Note: It is not necessary to use byte and short for integer operations in order to save memory. The range is too small. Even if it is determined that within the byte type, subsequent conversion to int will make the code redundant and difficult to maintain.
int i = 0 while(i>0){//Not an infinite loop, because overflow becomes negative i += 1000; }

Shift operation
Integers always exist in binary form in computers
//Move left, including truncating the corresponding bits to the left with 0 on the right int shitNum = 15;//00000000 00000000 00000000 00001111 int shitNumLeft1 = shitNum << 1;//00000000 00000000 00000000 00011110 System.out.println(shitNumLeft1);//Shift after binary conversion is equivalent to multiplying by an extra 2,30 int shitNumLeft2 = shitNum << 2;//00000000 00000000 00000000 00111110 System.out.println(shitNumLeft2);//Shift then converts binary by multiplying two more 2,60 int shitNumLeft28 = shitNum << 28;//11110000 00000000 00000000 00000000 System.out.println(shitNumLeft28);//Too many shifts can result in a negative number of 268435456, which means the left shift operation is risky to use as a multiplier of two //Move a negative number to the left, shift symbolically, which may change to positive, but also multiply by 2 shitNum = 15; int shitNumNevigateLeft = shitNum << 1; System.out.println(shitNumNevigateLeft);
Left shift is equal to multiply by 2. Symbol bits are within the truncation range, and positive and negative alternations may occur. If no loss of valid bits occurs, left shift by several bits is equal to multiply by several times of 2. If the number of bits moved is greater than 32, the remainder of the shift (shift 33 and shift 1 are the same) is calculated for 32 first, and there is no change after the shift.The original number, just get a new number.Note: Watch above to see that left shift cannot be used as multiplier 2 tool
//A positive right removal is a removal of 2, which ends up with 0, a removal truncation, and a right 0 to add int shitNum = 15;//00000000 00000000 00000000 00001111 int shitNumRight1 = shitNum >> 1;//00000000 00000000 00000000 0000111 System.out.println(shitNumRight1);//Shift after binary conversion is equivalent to dividing by a 2,7 int shitNumRight2 = shitNum >> 2;//00000000 00000000 00000000 00000011 System.out.println(shitNumRight2);//When converting binary after shift, it is equivalent to dividing two 2,3 int shitNumRight28 = shitNum >> 28;//00000000 00000000 00000000 00000000 System.out.println(shitNumRight28);//Too many shifts may cause 0 //Negative right shift also removes 2, but the highest bit stays the same, and the last one is 1, which is >> Right shift of unsigned bit for negative numbers int n = 536870912; int a = n >> 1; // 11110000 0000000 0000000 00000000 <= 268435456 int b = n >> 2; // 10111000 0000000 0000000 00000000 <= 134217728 int c = n >> 28; // 10000000 0000000 0000000 00000001 <= 2 int d = n >> 29; // 10000000 0000000 0000000 00000000 <= 1 //>> is the right shift of the signed bit, negative numbers become positive once the signed shift, but the absolute value may no longer be divided by 2 int n2 = 536870912; int a2 = n >>> 1; // 01110000 0000000 0000000 00000000 <= 1879048192 int b2 = n >>> 2; // 00111000 0000000 0000000 00000000 <= 939524096 int c2 = n >>> 29; // 00000000 0000000 0000000 00000111 <= 7 int d2 = n >>> 31; // 00000000 0000000 0000000 00000001 <= 1
Right removal is equivalent to removing 2, > symbol bits are no longer moved within the range, >> symbol bits are within the range of movement, too many moving bits may be 0, and rightshift operator species >> must be used as a division tool with high efficiency.If the number of bits moved is greater than 32, the remainder of 32 is first calculated on the shift remainder (shift 33 is the same as shift 1), and the original number is not changed after the shift, but a new number is obtained.

Bit operation
 And operation, two bit s are 1
 Or operation, any bit is 1
 NonOperational, 01 Interchange

XOR operation, two bit s different 1, same 0
int i = 167776589; // 00001010 00000000 00010001 01001101 int n = 167776512; // 00001010 00000000 00010001 00000000 System.out.println(i & n); // 167776512
2. Floating Point Operations
Floatingpoint arithmetic can only perform four numeric operations compared to integer arithmetic operations, no shift operation, bitwise operation, floatingpoint representation is larger than integer, but floatingpoint arithmetic cannot be accurately represented inside the computer.That is, there is an error in the operation of floatingpoint numbers, so the difference between two floatingpoint numbers is usually less than a very small number.
// To compare whether x and y are equal, first calculate the absolute value of the difference: double r = Math.abs(x  y); // Then decide if the absolute value is small enough: if (r < 0.00001) { // Can be considered equal } else { // Can be considered unequal }
Note: Integer dividing by 0 will cause an error, and floatingpoint dividing by 0 will return a special value
double d1 = 0.0 / 0; // NaN double d2 = 1.0 / 0; // Infinity double d3 = 1.0 / 0; // Infinity
3. Boolean operations
boolean always has only true and false values
Shortcircuit operation && , it is worth mentioning that ternary operators are also shortcircuit operators, the remaining expressions will not be executed after determining the result
4. Character string
There are two different types of characters and strings in Java
4.1char
Basic data type, a char holds a Unicode character, either directly assigning the character to the char variable or escaping the character u+Unicode code code value assignment, assigning the character to the int type can see the corresponding Unicode encoding.
For an introduction to Unicode encoding, see
char c = 'a'; char c = '\u0041'； int unicodeVlaue = 'a';
4.2String
By referencing a type variable, String is immutable because the source code modifies char[] with final, so assigning the same string variable twice creates a new string object that directly replaces the reference, and the original String object is recycled by the garbage collection mechanism.
String = "123 ";//Can contain spaces String = " 123 \"";//String uses''to identify the beginning and end of a string, and \ if the string itself contains', there are other escape characters String message = "Output:"; int num = 9; System.out.println(message + num);//+String splicing, which can be performed between multiple strings or with any other type of string to form a new string
A reference type variable can have a null value