Java Basic Data Types and Their Operations
Java Basic Data Types and Their Operations
1. Integer operations

Four Operations
For integer types, Java defines only signed integers, so the bit of the highest bit represents the symbol bit (0 represents a positive number, 1 represents a negative number). The maximum range of integers can be represented as follows:

byte: 128 ~ 127

short: 32768 ~ 32767

int: 2147483648 ~ 2147483647

long: 9223372036854775808 ~ 9223372036854775807
Therefore, there are spillovers. To solve the spillovers, we only need to change the specific number into binary to add and subtract. If the highest bit is changed to 1, the number after spillovers will become negative again.
Note: There is no need to use byte and short to perform integer operations in order to save memory. The scope is too small. Even if the byte type is determined, the later conversion from int to byte will make the code very redundant and difficult to maintain.
int i = 0 while(i>0){//It's not a dead cycle, because it overflows into negative numbers. i += 1000; }

Shift operation
Integers in computers always exist in binary form
//Left shift, which includes truncating the corresponding digits to the left and adding 0 to the right int shitNum = 15;//00000000 00000000 00000000 00001111 int shitNumLeft1 = shitNum << 1;//00000000 00000000 00000000 00011110 System.out.println(shitNumLeft1);//After shifting, when converting binary, it is equivalent to multiplying an additional 2,30. int shitNumLeft2 = shitNum << 2;//00000000 00000000 00000000 00111110 System.out.println(shitNumLeft2);//After shifting, when converting binary, it is equivalent to multiplying two more 2,60. int shitNumLeft28 = shitNum << 28;//11110000 00000000 00000000 00000000 System.out.println(shitNumLeft28);//Too many shifts may result in negative numbers  268435456, which means that the left shift operation is risky as a multiplier 2 tool. //Shift a negative number to the left, shift symbolically, and it may be positive, but it's also multiplied by 2. shitNum = 15; int shitNumNevigateLeft = shitNum << 1; System.out.println(shitNumNevigateLeft);
Left shift is equal to multiplying 2. Sign bits in the truncated range may alternate positively and negatively. If there is no loss of valid digits, then left shift is equal to multiplying several times of 2. If the number of moving digits is greater than 32, the remainder of 32 is first calculated in the shift residue (shift 33 is consistent with shift 1), and there is no change after the shift. The original number, just get a new number. Note: Looking at the above, we can see that the left shift can not be used as multiplier 2 tool.
//Positive right shift is to remove 2, and eventually it will be 0. The truncation that moves out will be complemented by zero on the right. int shitNum = 15;//00000000 00000000 00000000 00001111 int shitNumRight1 = shitNum >> 1;//00000000 00000000 00000000 0000111 System.out.println(shitNumRight1);//After shift, when converting binary, it is equal to dividing by 2,7. int shitNumRight2 = shitNum >> 2;//00000000 00000000 00000000 00000011 System.out.println(shitNumRight2);//After shifting, when converting binary, it is equivalent to dividing two 2,3. int shitNumRight28 = shitNum >> 28;//00000000 00000000 00000000 00000000 System.out.println(shitNumRight28);//Excessive displacement may cause 0 //Negative number right shift is also divided by 2, but the highest bit is fixed, and finally  1, that is to say, > For negative number, it is right shift without sign bit. 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, and the negative number becomes positive once the signed bit is shifted, but the essential 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
Rightshift is equivalent to remove 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> can certainly be used as a division tool, and the efficiency is high. ** If the number of digits moved is greater than 32, the remainder of 32 is first calculated in the shift residue (shift 33 is the same as shift 1), and after the shift, the original number is not changed, but a new number is obtained.

Bit operation
 With operation, two bit s are equal to 1
 Or operation, any bit is 1
 NonOperational, 01 Interchange
 XOR operation, two bit s different 1, the 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
Compared with integer operations, floatingpoint operations can only perform four numerical operations, not shift operations, bit operations, and the table demonstration range of floatingpoint operations is larger than that of shaping, but floatingpoint operations can not be accurately expressed in the computer. That is to say, there are errors in the operation of floatingpoint numbers, so the difference between two floatingpoint numbers is usually less than a very small number.
// Comparing whether x and y are equal, the absolute value of the difference is calculated first. double r = Math.abs(x  y); // Then determine whether the absolute value is small enough: if (r < 0.00001) { // Equality can be considered } else { // Can be considered unequal }
Note: Errors will be reported when integer divides by 0, and special values will be returned when floatingpoint divides by 0.
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, after determining the results, the remaining expressions will not be executed.
4. Character strings
In Java, characters and strings are two different types.
4.1char
The basic data type, a char saves a Unicode character, which can be assigned directly to the char variable, or can escape the character u+Unicode encoding value assignment. If the character is assigned to the int type, the corresponding Unicode encoding can be seen.
For an introduction to Unicode coding, see
char c = 'a'; char c = '\u0041'； int unicodeVlaue = 'a';
4.2String
Referring to type variables, String is immutable, because the source code modifies char [], so the second assignment of the same string variable, in fact, creates a new string object to directly replace the reference, the original String object will be recycled by the garbage collection mechanism.
String = "123 ";//Can contain spaces String = " 123 \"";//String uses "" to mark the beginning and end of a string. If the string itself contains ", use ", and there are other escape characters. String message = "Output:"; int num = 9; System.out.println(message + num);//+ For string splicing, it can be performed between multiple strings, or it can be used to splice strings with any other type to form new strings.
The value of a reference type variable can be null