1, Operator

​ In Java, operators used for program calculation are generally called operators, which are divided into the following categories

1. Arithmetic operator

//Summary + + -- has higher priority than +, -, *, /,%

public static void main(String[] args){
    //+,-,*,/,% 	 All operators must ensure consistent data types during calculation
    int num1 = 100;
    int num2 = 200;
    int sum = num1 + num2;
    int mul =  num1-num2;
    int num3 = -num2;   // -200
    System.out.println("Add two numbers" +  sum); // +Represents a connector
    System.out.println("Subtract two numbers" + mul);
    System.out.println( "num2: " + num2+ " ,num3:" + num3 );
    System.out.println("num1+num2="+ (num1+num2) );
    
    int sum2 = num1*num2;
        int sum3 = num1/num3;
        System.out.println(sum3);   
       // System.out.println(num1/sum3); // Arithmetic exception: / by zero
        // Take mold
        System.out.println( 10%2);//0
        System.out.println(1%5);// 1
        System.out.println(2%5);
}

public static void main(String[] args) {
// Self addition and self subtraction + + -- only integers can be added
        int i=1;
        i++ ;     // i = i + 1
        System.out.println("i:" + i);
        int j=1;
        ++j;    // j = j + 1
        System.out.println("j:" + j);

        int a =1;
        int sum = a++;  // First assign the value of a to sum, and then add 1 to a
        int sum2 = ++a; // First add a by itself, and then assign the result of self addition to sum2
        System.out.println("sum:" + sum);
        System.out.println("sum2:" + sum2 );
        System.out.println("a:" +a);  // 3

        int sum3 = a++ + a++ ;
        System.out.println("sum3:"+sum3);
        System.out.println("a:"+a);

        // --The operation is similar to + + operation
        int b=1;
        int s1= b--;  // The value of B = B - 1 S1 is assigned first and then subtracted by 1 S1 = 1
        int s2 =  --b; // B = B - 1. The value of S2 is to subtract 1 first and then assign s2 = -1
        System.out.println("b:"+b);
        System.out.println("s1:"+s1);
        System.out.println("s2:"+s2);

        // ++-- Comprehensive
        int x=1;
        int y=2;
        int s3 = x++ + --x * (y-- + ++x);
        System.out.println("x:"+x);// 2
        System.out.println("y: "+y);// 1
        System.out.println("s3:"+s3);// 5
    }

2. Comparison operator

Used to compare the results between two expressions. The results return true and false

The comparison operator cannot be run as a single line of code. It must receive the result or output

Note: it is not allowed to write together, for example, 1 < 3 < 5

public static void main(String[] args) {
          // Comparison operator
        int a =1;
        int b =2;
       // a>b;  //  Cannot be compared alone. Results or outputs must be accepted
        System.out.println(a>b);  //false
        System.out.println(a<b);  //true
        System.out.println(a==b); //false
        System.out.println(a!=b); //true
        // Add logical judgment
        // If the condition after if is true, execute the statement in if. If not, just use else statement
        if(a>b){
            System.out.println("a>b establish");
        }else{
            System.out.println("Not established");
        }

    }

3. Assignment operator

Assign the result of the expression to a variable, which can only be assigned to variables, not constants

For example: a = 3

// Assignment operator = + = - = * = / =%=
        int a=2;
        a+=2;
        System.out.println(a);// 4
        a-=3;
        System.out.println(a);// 1
        a*=2;
        System.out.println(a); // 2
        a/=4;
        System.out.println(a);// 0

        a+=a-=3; // a+=(a-=3) -> a=a +(a=a-3 )
        System.out.println("a="+a);

        int x=2;
        x+=x-=x*=x++;
        //x = x +(x = x -( x= x *(x++) ))
        // x = 2 + ( x = 2 - (x = 2 * 2))
        // x =  2 + ( 2 - 4)
        // x = 0
        System.out.println("x="+x);

        //The assignment operator has the lowest priority and is calculated from right to left
        int y=2;
        y*=y+=y; // It is also calculated from right to left
        // y = y * (y = y + y);
        // y = 2 * (2+2)
        // y =8;
        System.out.println("y="+y);

4. Logical operator

In Java, it is used for two or more expressions to take the result of logical judgment. Logical operators are usually required

  // Logical operator
        System.out.println(true & true); // true
        System.out.println(true & false);// false
        System.out.println(false & true); // false
        System.out.println(false & false);// false
        // true&true
        System.out.println(1>0 & 3>1);
        System.out.println(1>0 && 3>1);
        // |Or
        System.out.println(true | true); //true
        System.out.println(true | false);// true
        System.out.println(false | true); // true
        System.out.println(false | false);// false
        // ||Short circuit or
        System.out.println(true || false) ;// true

Summary: & the difference between & & and | the difference between | and |?

Answer 1, & the expressions on both sides of the symbol will be executed & & if the left side of the symbol is false, the right side will not be executed

​ | The expressions on both sides of the symbol will be executed. If the left side of the symbol is true, the right side will not be executed

2. Numbers can be written directly on both sides of &, | and calculated by bit. Short circuit symbols cannot directly calculate numbers

int a=1;
        int b=2;
     //   System. out. println(a>b && b++>0);  //  No operation to the right of the symbol
     //   System.out.println("b:"+b);

        System.out.println(a>b & b++>0); // Run on both sides of the symbol
        System.out.println("b:"+b);

        // ||The difference between and
      //  System. out. println(a>=1 ||  a++<0); //  A + + does not execute
      //  System.out.println("a:"+a);

        System.out.println(a>=1 | a++<0 );  // a + + will execute
        System.out.println("Output again a : " + a);

Decimal to binary

For any decimal to binary conversion, first find the multiple of 2 that is smaller than it and closest to it, and then calculate the binary difference (using the split method)

For example, 28 = 16 + 8 + 4 = 11100

​ 34 = 32+2 = 100010

​ 96 = 64+32 = 1100000

Binary to decimal

Formula: starting from bits, the sum of the number on each bit multiplied by the n-th power of 2

100100 = power 2 of 1 * 2 + power 5 of 1 * 2 = 36

5. Bitwise operator

//Shift of positive integer < < > > >
        System.out.println(3<<2);  // 12
        System.out.println(7<<3); // 7*8=56

        // For positive numbers, the unsigned right shift results in the same way as the right shift
        System.out.println(16>>2);// 4
        System.out.println(18>>2);// 4

        System.out.println(5^9);//12


        System.out.println(3>>2);
        System.out.println(3>>>2);

        System.out.println(~5);

// Shift of negative numbers
        // Is the left shift of a negative number negative
        System.out.println(-4<<2); // -4 * 2 to the power of 2=
        /**
         *   -4 Original code: 10000 00000100
         *          *   -4 Inverse code: 1 1111 eleven million one hundred and eleven thousand and eleven
         *          *   -4 Complement of: 1 1111 eleven million one hundred and eleven thousand and one hundred
         *          *   Start shift 2
         *             1 1111... 11110000
         *    Final result = negative + 1
         *             1 0000... 00001111  + 1
         *  : 
         *             1 0000... 00010000  =-16
         */

        //Complement = inverse + 1
        //Negative numbers shift the complement - 4 / 2 = - 2
        System.out.println(-4>>1);

        // -16 unsigned shift right 2 bits
        System.out.println(-16>>>2);   //1073741820   
        // -Calculate the complement of 16
        /**
         * Original code 10000 0010000
         * Inverse code 11111 one million one hundred and one thousand one hundred and eleven
         * Complement 11111 one million one hundred and ten thousand
         *      00111.. 1111100  Since the sign does not move, it becomes a positive number after all the high numbers are added
         *      If the original code of a positive number is consistent with the complement, this number is the result
         *      1073741820
         */

6. Ternary operator

​ expression? Result 1: result 2

When? When the previous is true, the whole expression outputs the result 1. If? If the previous is not true, output result 2

// Generate random numbers within 100
        int n = (int)(Math.random()*100);
        System.out.println("n:"+n);
        System.out.println( n%2==0 ?"This number is even":"This number is odd");

2, Expression, statement block

​ Expression: an element composed of operators and operands. The expression cannot be written in the program alone. It needs to accept the result or output.

There may be multiple operators in the expression at the same time. At this time, the priority of operators needs to be considered

Note: the () here represents the bracket of the method, the dot represents the decimal point, and [] represents the subscript of the array

2-5: used to get the result value

6-12: used to calculate true and false

13,14: Yes assignment. The assignment has the lowest priority

Statement block:

In a method, {} can be used to represent a statement block, or it can be placed outside the method and inside the class, which is called an independent code block

 public static void main(String[] args) {
         //Define a code block in a method
        {
            // A local variable can only be used in its region
            int a=1;
            a++;
            System.out.println("This is the code block in a method "+a);
        }
       // a++;
        if(true){
            System.out.println("This is a if Code block");
        }
    }