Operator overview
Operator: a symbol that operates on constants or variables. There are many kinds of Java operators that make up an expression (what are operands and operators, such as 1 + 2, where # 1 # and # 2 # are operands, + is an operator, and operators and operands combine to form an expression). Operators are divided according to the number of operands they require. They can include unary operators (1 ￠ operands), binocular operators (2 ￠ operands) and ternary operators (3 ￠ operands). Operators are divided according to their functions:
 Arithmetic operator
 Assignment Operators
 Comparison operator (relational operator)
 Logical operator
 Bitwise Operators
 Ternary operator
Operators have priority, so if you are not sure what to do with their priority, it's actually very simple. Just add parentheses directly. The priority with parentheses must be high, so you don't need to memorize the priority. If you are not sure, add parentheses, for example: 1 + 2 * 3. To ensure the sum first, you need to write: (1 + 2) * 3.
Arithmetic operator
Arithmetic operators include: + (sum of two numbers),  (subtraction of two numbers), * (product of two numbers), / (division of two numbers),% (modulo or remainder of two numbers), + + (monocular operator, add 1 to the number),  (monocular operator, subtract 1 from the number). As shown in the figure below:
matters needing attention:
 /The difference between% and%: divide the two data, / take the quotient of the result, and% take the remainder of the result. Integer operation can only get integers. To get decimal points, floatingpoint numbers must be involved in the operation. Modulo operations are also valid for floatingpoint numbers
 If you take the modulus of a negative number, you can ignore the negative sign of the modulus, such as 5%  2 = 1. However, if the modulus is negative, it cannot be ignored. In addition, the result of modulo operation is not always an integer
Code example
/* Division formula: Quotient = divisor / divisor remainder For the expression of an integer, the division method uses integer division. When an integer is divided by an integer, the result is still an integer. Just look at the quotient, not the remainder. Only for the division of integers, the modular operator has the meaning of remainder. matters needing attention: 1. Once there are different types of data in the operation, the result will be the one with a wide range of data types. */ public class Demo02Operator { public static void main(String[] args) { // Mathematical operations can be performed between two constants System.out.println(20 + 30);//50 // Mathematical operations can also be performed between two variables int i = 20; int t = 30; System.out.println(i  t); // 10 // Variables and constants can be mixed System.out.println(i * 10); // 200 int x = 10; int y = 3; int result1 = x / y; System.out.println(result1); // 3 int result2 = x % y; System.out.println(result2); // 1 // int + double > double + double > double double result3 = x + 2.5; System.out.println(result3); // 12.5 //Any four digits, flashback output, such as digital 1234 output 4321 int a = 1234; //Get single digit int g = a % 10; //Get ten digits int s = a / 10 % 10; //Get hundreds int b = a / 100 % 10; //Get thousands int q = a / 1000; //Flashback output System.out.print(g); System.out.print(s); System.out.print(b); System.out.print(q); } }
Character "+" operation: take the value corresponding to the character at the bottom of the computer to calculate
When an arithmetic expression contains values of multiple basic data types, the type of the entire arithmetic expression will be automatically promoted. Promotion rules:
 byte type, short type and char type will be promoted to int type
 The type of the whole expression is automatically promoted to the same type as the highest level operand in the expression. The level order is shown in the following figure:
Code example
public class VariableTest1 { public static void main(String[] args) { //Define two variables int i = 10; char c = 'A'; //The value of 'A' is 65 c = 'a'; //The value of 'a' is 97 System.out.println(i + c);//107 c = '0'; //The value of '0' is 48 //char ch = i + c; //char type is automatically promoted to int type int j = i + c; System.out.println(j);//58 } }
String "+" operation: in the "+" operation, if a string appears, it is a connection operator, otherwise it is an arithmetic operation. When the "+" operation is carried out continuously, it is carried out one by one from left to right.
/* The plus sign "+" in the four operations has three common uses: 1. For numerical values, that is addition. 2. For character char type, char will be promoted to int before calculation. char Comparison table between type characters and int type numbers: ASCII and Unicode 3. For the String string (capitalized, not keyword), the plus sign represents the String concatenation operation. When any data type is connected with a string, the result will become a string */ public class Demo { public static void main(String[] args) { // Basic use of string type variables // Data type variable name = data value; String str1 = "Hello"; System.out.println(str1); // Hello System.out.println("Hello" + "World"); // HelloWorld String str2 = "Java"; // String + int > String System.out.println(str2 + 20); // Java20 // Priority issues // String + int + int // String + int // String System.out.println(str2 + 20 + 30); // Java2030 System.out.println(str2 + (20 + 30)); // Java50 } }
Self increasing and self decreasing operator (belonging to arithmetic operator)
Explain in detail
 Basic meaning: let a variable increase by a number 1, or let a variable decrease by a number 1
 Use format: write before or after the variable name. For example, + + i, or i++
Usage:
 Use alone: it is not mixed with any other operation and becomes a step independently.
 Mixed use: mixed with other operations, such as assignment, printing, etc.
Use difference:
 When used alone, there is no difference between pre + + and post + +. That is: + + i; And i + +; It's exactly the same.
 When mixing, there are [significant differences]
 If it is [first + +], the variable [immediately + 1], and then use it with the result.
 If it is [post + +], first use the original value of the variable, [and then let the variable + 1].
matters needing attention:
 Only variables can use self increasing and self decreasing operators. Constants cannot be changed, so they cannot be used.

Whether it is before + + /   or after + + /  , as long as the execution of + + / , the final result will make the variable increase by  1 / decrease by 1.
Code example
package demo; public class Demo { public static void main(String[] args) { int num1 = 10; System.out.println(num1); // 10 ++num1; // Used alone, before++ System.out.println(num1); // 11 num1++; // Used alone, after++ System.out.println(num1); // 12 // When mixed with printing operation int num2 = 20; // Mixed use, first + +, the variable immediately becomes 21, and then print the result 21 System.out.println(++num2); // 21 System.out.println(num2); // 21 int num3 = 30; // After mixed use, + +, first use the original 30 of the variable, and then let the variable + 1 get 31 System.out.println(num3++); // 30 System.out.println(num3); // 31 int num4 = 40; // Mixed with assignment operation int result1 = num4; // Mixed use, before , the variable immediately  1 becomes 39, and then give the result 39 to the result1 variable System.out.println(result1); // 39 System.out.println(num4); // 39 int num5 = 50; // After mixed use , first give the original number 50 to result2, and then  1 becomes 49 myself int result2 = num5; System.out.println(result2); // 50 System.out.println(num5); // 49 int x = 10; int y = 20; // 11 + 20 = 31 int result3 = ++x + y; System.out.println(result3); // 31 System.out.println(x); // 11 System.out.println(y); // 19 // 30++; // Wrong writing! Constants cannot use + + or } }
Relational operator
Relational operators are mainly used to complete the comparison between data. For example, if 5 > 3, the result is true, if 5 > 10, the result is false.
be careful:
 The result of the comparison operator must be a boolean value. If it is true, it is false. Never mistake "= =" for "=".
 If you make multiple judgments, you can't write in succession. The writing method in mathematics, for example, 1 < x < 3 [not allowed] in the program
Code example
/* One rule to remember: The results of all relational operators are Boolean, Either true or false. It can't be any other value. In the java language: = : Assignment Operators == : Relational operators to determine whether they are equal. Note: if there are two symbols in a relational operator, there can be no space between the two symbols. >= This is right, > = this is wrong. == This is right, = = this is wrong. */ public class Demo { public static void main(String[] args) { System.out.println(10 > 5); // true int num1 = 10; int num2 = 12; System.out.println(num1 < num2); // true System.out.println(num2 >= 100); // false System.out.println(num2 <= 100); // true System.out.println(num2 <= 12); // true System.out.println("==============="); System.out.println(10 == 10); // true System.out.println(20 != 25); // true System.out.println(20 != 20); // false int x = 2; // System. out. println(1 < x < 3); // Wrong writing! Compilation error! You can't write in succession. } }
Assignment Operators
The operators of assignment class include basic assignment operators (=) and extended assignment operators (+ =,  =, * =, / =,% =).
matters needing attention:
 Only variables can use assignment operators, and constants cannot be assigned.
 The assignment operator operates directly on the original variable, so it will not change the data type of the variable. The compound assignment operator implies a forced type conversion.
 When the assignment operator is written, there must be no space between two symbols. When using this operator, you must ensure that the result of data operation cannot exceed the maximum value range of the data type on the left, otherwise unpredictable results will appear
 =Assign the value on the right to the variable on the left. Be sure to assign the value after all the code operations on the right are completed

When the data types on both sides of "=" are inconsistent, you can use automatic type conversion or mandatory type conversion principle for processing. Continuous assignment is supported. Not recommended
Code example
/* Assignment operators are divided into: Basic assignment operator: it is an equal sign "=", which means to give the data on the right to the variable on the left. The right side of the assignment operator "=" has higher priority, and the expression on the right side shall be executed first int a = 30; Compound assignment operator: += a += 3 Equivalent to a = a + 3 = b = 4 Equivalent to b = b  4 *= c *= 5 Equivalent to c = c * 5 /= d /= 6 Equivalent to d = d / 6 %= e %= 7 E = 7% */ public class Demo03Operator { public static void main(String[] args) { int i = 10; // Translate according to the formula: a = a + 5 // a = 10 + 5; // a = 15; // a was originally 10, but now it is reassigned to 15 i += 5; System.out.println(i); // 15 int x = 10; // x = x % 3; // x = 10 % 3; // x = 1; // x was originally 10, but now it is reassigned to 1 x %= 3; System.out.println(x); // 1 // 50 = 30; // Constants cannot be assigned and cannot be written to the left of the assignment operator. Wrong writing! byte num = 30; // num = num + 5; // num = byte + int // num = int + int // num = int // num = (byte) int num += 5; System.out.println(num); // 35 //Variable exchange int a = 30; int b = 40; int temp; //Use intermediate variables temp = a; a = b; b = temp; System.out.println(a);//40 System.out.println(b);//30 int c = 11; int d = 21; //Variable exchange does not use intermediate variables c = c + d; d = c  d; c = c  d; System.out.println(c);//21 System.out.println(d);//11 } }
Logical operator
It mainly includes logic and (&), logic or (), logic XOR (^), short circuit and (& &), short circuit or (). The characteristic of all logical operators is that the operands are Boolean, and the final operation result is also Boolean.
be careful:
 Logical operators are used to connect Boolean expressions. They cannot be written as 3 < x < 6 in Java, but should be written as x > 3 & x < 6.
 Logic and &, whether true or false on the left, must be executed on the right.
 Short circuit and &, if the left is true, execute on the right; If the left is false, the right is not executed.
 Logic or , whether true or false on the left, must be executed on the right.
 Short circuit or if the left is false, execute on the right; If the left is true, the right is not executed.
Common logical operators
Code example
/* And (and) & & are all true, is true; Otherwise, it is false Or (or)  at least one is true, which is true; It's all false. It's false Not (reverse)! Originally true, it becomes false; It used to be false, but it became true And "& &", or "", with short circuit effect: If the final result can be judged from the left, the code on the right will no longer be executed, thus saving some performance. matters needing attention: 1. Logical operators can only be used with boolean values. 2. And, or need to have a boolean value on the left and right respectively, but the reverse can only have a unique boolean value. 3. And, or two operators. If there are multiple conditions, they can be written continuously. Two conditions: condition a & & condition B Multiple conditions: condition a & & condition B & & condition C TIPS: For the case of 1 < x < 3, it should be split into two parts and then connected with the and operator: int x = 2; 1 < x && x < 3 */ public class Demo { public static void main(String[] args) { System.out.println(true && false); // false // true && true > true System.out.println(3 < 4 && 10 > 5); // true System.out.println("============"); System.out.println(true  false); // true System.out.println(true  true); // true System.out.println(false  false); // false System.out.println("============"); System.out.println(true); // true System.out.println(!true); // false System.out.println("============"); int a = 10; // false && ... System.out.println(3 > 4 && ++a < 100); // false System.out.println(a); // 10 System.out.println("============"); int b = 20; // true  ... System.out.println(3 < 4  ++b < 100); // true System.out.println(b); // 20 } }
ternary operator
Execution process:
 First, evaluate the value of the relationship expression
 If the value is true, the value of expression 1 is the result of the operation
 If the value is false, the value of expression 2 is the result of the operation
Code example
/* Format: Data type variable name = condition judgment? Expression A: expression B; technological process: First, judge whether the conditions are true: If true, assign the value of expression A to the variable on the left; If it is not false, assign the value of expression B to the variable on the left; Choose one of the two. */ public class Demo{ public static void main(String[] args) { int a = 10; int b = 20; // Data type variable name = condition judgment? Expression A: expression B; // Judge whether a > b is true. If it is true, assign the value of a to max; If not, assign the value of B to max. Choose between the two int max = a > b ? a : b; // Maximum variable System.out.println("Maximum:" + max); // 20 // int result = 3 > 4 ? 2.5 : 10; // Wrong writing! System.out.println(a > b ? a : b); // Write correctly! // a > b ? a : b; // Wrong writing! } }
Note: the data type of expression A and B must meet the requirements at the same time. The results of ternary operators must be used if they are not saved with variables.
Bitwise Operators
Bit operation is an operation directly on the binary of an integer, and the operation of the {bit operator is integer data.
Code example
/* Conclusion: 1. Bitwise operators operate on integer data 2. << : Within a certain range, every 1 bit to the left is equivalent to * 2 >> :Within a certain range, each shift to the right is 1 bit, which is equivalent to / 2 Interview question: the most efficient way to calculate 2 * 8? 2 < < 3 or 8 < < 1 */ class BitTest { public static void main(String[] args) { int i = 21; i = 21; System.out.println("i << 2 :" + (i << 2)); System.out.println("i << 3 :" + (i << 3)); System.out.println("i << 27 :" + (i << 27)); int m = 12; int n = 5; System.out.println("m & n :" + (m & n)); System.out.println("m  n :" + (m  n)); System.out.println("m ^ n :" + (m ^ n)); //Exercise: exchanging the values of two variables int num1 = 10; int num2 = 20; System.out.println("num1 = " + num1 + ",num2 = " + num2); //Method 1: how to define temporary variables //Recommended way int temp = num1; num1 = num2; num2 = temp; //Method 2: benefits: no need to define temporary variables //Disadvantages: ① addition operation may exceed the storage range ② limitations: it can only be applied to numerical types //num1 = num1 + num2; //num2 = num1  num2; //num1 = num1  num2; //Method 3: use bitwise operators //Limitations: can only be applied to numeric types //num1 = num1 ^ num2; //num2 = num1 ^ num2; //num1 = num1 ^ num2; System.out.println("num1 = " + num1 + ",num2 = " + num2); } }
About hexadecimal
All numbers exist in binary form at the bottom of the computer.
For integers, there are four representations:
 Binary: 0,1, full 2 into 1 Start with 0b or 0b.
 Decimal: 09, full 10 into 1.
 Octal: 07, full 8 into 1 Start with the number 0.
 Hexadecimal (hex): 09 and AF, full 16 into 1 It starts with 0x or 0x. AF here is not case sensitive. For example: 0x21AF +1= 0X21B0
Binary
Java integer constant is of type int by default. When an integer is defined in binary, its 32nd bit is the sign bit; When it is a long type, binary occupies 64 bits by default, and the 64th bit is the sign bit
Binary integers have the following three forms:
 Original code: directly change a numerical value into a binary number. The highest bit is the sign bit
 Inverse code of negative number: it reverses the original code by bit, but the highest bit (sign bit) is determined as 1.