运算符

算术运算符

1. + 
   java语言中唯一重载[具有多个意义]的运算符
   数值之间表示的加法运算,如果出现了"字符串",表示拼接[后面就会知道拼接效率很低]
  
2. - 减法   * 乘法
  
3. / 除法[配合计算过程中需要注意的结果的类型而已] - 取整
  
4. % 取余/模
   /和%结合使用,可以获取某个数字任意位上的数值.
  
5. += -= *= /= %=
   未来知道:开发中尽量不要使用,不是一个原子操作,导致多线程不安全.
   底层会判断是否需要进行一个类型的窄化操作[类型的强制转换操作]
     
6. ++和--
   前++/后++ - 变量本身都会自增1
   前--/后-- - 变量本身都会自减1
   未来知道:开发中尽量不要使用,不是一个原子操作,导致多线程不安全.
   底层会判断是否需要进行一个类型的窄化操作[类型的强制转换操作]

比较运算符

> <= >= < !=
比较得到的结果是一个boolean类型即可

逻辑运算符

&& - 逻辑与,短路与.作用不是用来进行计算的,而是用来连接条件[多个,条件表达式(包含比较运算符)]的.

为true - 所有的条件表达式都是返回true

短路的特性:当左边的条件表达式已经能够决定整个结果了,那么后面的条件表达式将不会执行.

推荐:将条件表达式结果最有可能为false的放在最左边 - 提高代码的执行效率.

|| - 逻辑或,短路或.作用不是用来进行计算的,而是用来连接条件[多个,条件表达式(包含比较运算符)]的.

为true - 只要有一个表达式是true,那么结果就是true

短路的特性:当左边的条件表达式已经能够决定整个结果了,那么后面的条件表达式将不会执行.

推荐:将条件表达式结果最有可能为true的放在最左边 - 提高代码的执行效率.

! - 逻辑非,true成为false,false成为true

位运算符

& - 按位&,非短路与,最主要的作用就是用来计算的,但是可以用来连接条件表达式.

计算:都是1,结果才是1.只要出现1个0,那么结果就是0

连接条件:为true - 所有的条件表达式都是返回true

10 & 8 = 8
          
十进制的数不断除以2,直到商为0,然后倒过来取余数 - 1010
10 / 2 = 商5......余0
5 /  2 = 商2 ...... 1
2/  2 =  1 ........ 0
1/2  =   0 .........1
          
  1    0    1   0
        
& 1    0    0   0
------------------
  1    0    0   0  -> 对应的十进制8

| - 按位或,非短路或,最主要的作用就是用来计算的,但是可以用来连接条件表达式.

计算:只要存在一个1,结果就是1

连接条件:为true - 只要存在一个条件表达式为true.
```
10 | 8 = ?
  
  1    0    1   0

| 1    0    0   0
------------------
  1    0    1   0  -> 对应的十进制10
```

异或^

作用:进行计算的 - 相同为0,不同为1

10 ^ 8 = 2 
1    0    1   0
      
| 1    0    0   0
------------------
  0    0    1   0  -> 2
  
  
10 ^ 8 ^ 8 = 10

0    0    1   0 
1    0   0    0
-----------------
      1   0    1    0    -> 10

结论:一个数字连续异或同一个数字俩次结果是它本身.
可以进行加密和解密的操作

   笔试题: 交换俩个变量的值,不允许出现第三方变量
   package tech.aistar.day02;

      /**
    * 本类用来演示: 笔试题: 交换俩个变量的值,不允许出现第三方变量
    *
    * @date: 2021/7/16 11:09 上午
    */
   public class ChangeVarValue {
       public static void main(String[] args) {
           //1. 使用第三方变量
           int a = 10;
           int b = 20;
           int temp = a;
           a = b;
           b = temp;
           System.out.println("a:"+a);
           System.out.println("b:"+b);

              //一个数字连续异或同一个数字俩次结果是它本身.
           int m = 100;
           int n = 200;
           m = m ^ n;//m = 100 ^ 200
           n = m ^ n;//n = 100 ^ 200 ^ 200 = 100
           m = m ^ n;//m = 100 ^ 200 ^ 100 = 200

              System.out.println("m:"+m);
           System.out.println("n:"+n);

              //自创写法(success独家的) - 不推荐写 - 防止菜鸟看不懂
           int x = 100;
           int y = 200;

              //y = 100 ^ 200 ^ 200 = 100
           y = x ^ (x = y) ^ y;

              System.out.println("x:"+x);
           System.out.println("y:"+y);
       }
   }

取反~,1变0,0变成1

补码 - 负数在计算机中的表现形式就是以补码的形式存在的

补码 = 反码 + 1;
反码 = 原码符号位不变,其余位依次取反
符号位 - 最高位代表的是符号位.1代表的是负数,0代表的是正数.
反码本身没有意义的,它的存在就是为了计算补码

正数的补码,反码,原码都是它本身.

计算一下:-10的二进制是多少?-10的补码是多少?
  
计算步骤:
1. -10原码
   10000000 00000000 00000000 00001010

2. -10的反码
   10000000 00000000 00000000 00001010
   11111111 11111111 11111111 11110101
  
3. -10的补码 = 反码+1
   11111111 11111111 11111111 11110101
 +                                   1
  -------------------------------------
   11111111 11111111 11111111 11110110    ->  -10的二进制
  
计算~9
00000000 00000000 00000000 00001001
11111111 11111111 11111111 11110110  -> ~9取反的结果
  
-10 = ~9
  
结论:-(x+1) = ~x

移位操作

笔试题 - 计算性能最高的操作,jdk源码里面很多都是移位操作

<< 向左移动
2<<2 => 0010 << 2 = 1000 = 8
原题:请你用最高性能的方式计算出2的3次方.
>> 带符号的右移动,向右移动多少位,那么就在最高位补符号位
-10 >> 2 = -3
11111111 11111111 11111111 11110110 >> 2
11111111 11111111 11111111 11111101 -> 负数的二进制,最高位是1

00000000 00000000 00000000 00000010 取反 ~2=-3
  
>>> 不带符号的右移动,向右移动多少位,就在最高位补0
 -10 >>> 2
 11111111 11111111 11111111 11110110 >> 2
  
 00111111 11111111 11111111 11111101 -> 计算出十进制
 01000000 00000000 00000000 00000000
   -                                  3
-----------------------------------------
     1073741821