1byte（字节）=8bit（比特）

1

  0 0 0 0 0 0 0 1   2进制的1的原码 反码 补码

  0 0 0 0 0 0 0 0   2进制的0的原码 反码 补码

  -1

  1 0 0 0 0 0 0 1 

   计算机中真正参与运算的是  补码！

  在java中所有的数字都是有符号的！  符号就是  正 0   负 1

   最高位（最左边的）的 0和1 就是 符号位

 什么是最高位？ 就是最左边的数字！

  java中最小的单位是 byte（字节）

生活中我们买了一个50G的内存条！ 插入到我们的电脑中 有50G吗？？

  没有！ 因为所有的厂商都是以  1G=1000MB 来计算的！

 但是我们的电脑 是以  1G=1024MB 来计算的！所以 不足50G！

　　　　  原码：第一位是符号位

反码：符号位不动，原码去反

补码：正数的补码和原码相同

  负数的补码：符号位不动，反码+1

1+2

0 0 0 0 0 0 0 1

+0 0 0 0 0 0 1 0

——————–

    0 0 0 0 0 0 1 1 ==》  1*2的0次方+1*2的1次方 ===》3

符号位 就是 最高位（最左边的）

 0  正数

 1  负数

-1

 1 0 0 0 0 0 0 1

-2

 1 0 0 0 0 0 1 0   

 1 – 2

     01.找到-2的原码

  1 0 0 0 0 0 1 0      02.需要把原码转换成反码

  1 1 1 1 1 1 0 1      03.反码需要转换成补码

  1 1 1 1 1 1 1 0      04.得到-2 运算的 补码

+ 0 0 0 0 0 0 0 1

—————————     

  1 1 1 1 1 1 1 1      得到的是结果的补码   需要转换成反码 再转换成原码

  1 1 1 1 1 1 1 0      得到了结果的反码

  1 0 0 0 0 0 0 1      得到了结果的源码   -1

4  – 3

 1 0 0 0 0 0 1 1      01.找到-3的原码  把原码转换成反码

 1 1 1 1 1 1 0 0      02.反码需要转换成补码

 1 1 1 1 1 1 0 1      03.得到补码 可以运算

+0 0 0 0 0 1 0 0      

———————————————

 0 0 0 0 0 0 0 1      结果是正数  1

注意点

01. 计算机中运算的都是补码

02. 正数和0的反码补码原码都是一致的

03. 在java中所有的数字都是有符号

04. 负数的反码=符号位不变+其他位取反（0=1  1=0）

05. 负数的补码=反码+1

算术右移    ：  符号位不变，低位溢出删除！ 高位补零！

int newCapacity = oldCapacity + (oldCapacity >> 1);

int newCapacity=10+(10 >> 1);

10 >> 1

10: 指的是需要位移的数字

>>：位移方向

1 ：位移的位数

 01.首先找到10的2进制

 0 0 0 0 1 0 1 0

   0 0 0 0 1 0 1 0       02.右移一位

————————-

 0 0 0 0 0 1 0 1        1*2的0次方+1*2的2次方=5

算术左移  ：   符号位不变，高位溢出删除！ 低位补零！

   10  <<  1

    01.首先找到10的2进制

     0 0 0 0 1 0 1 0

   0 0 0 0 1 0 1 0       02.左移一位

————————————

     0 0 0 1 0 1 0 0     1*2的2次方+1*2的4次方=20

 逻辑右移：  不管符号位！ 低位溢出删除！ 高位补零！    没有逻辑左移！！！

 10 >>> 2

 0 0 0 0 1 0 1 0

     0 0 0 0 1 0 1 0

—————————

 0 0 0 0 0 0 1 0     1*2的1次方=2

 -1

  1 0 0 0 0 0 0 1    01.原码

  1 1 1 1 1 1 1 0    02.反码

  1 1 1 1 1 1 1 1    03.补码

    1 1 1 1 1 1 1 1  04.右移一位  高位补零  

———————————–

  0 1 1 1 1 1 1 1 

===》  结果2147483647

位运算：

01.按位与 &  ：  两位都为1，结果为1

 3 & 4

   0 0 0 0 0 0 1 1 

&  0 0 0 0 0 1 0 0

————————-

   0 0 0 0 0 0 0 0

2 & 3

   0 0 0 0 0 0 1 1 

&  0 0 0 0 0 0 1 0 

———————

   0 0 0 0 0 0 1 0 

02.按位与 |：两位有一个为1，结果为1

 3 | 4

   0 0 0 0 0 0 1 1 

|  0 0 0 0 0 1 0 0

————————-

   0 0 0 0 0 1 1 1

2 | 3

   0 0 0 0 0 0 1 1 

|  0 0 0 0 0 0 1 0 

———————

   0 0 0 0 0 0 1 1 

03.按位异或 ^  ：两位必须是一个为0 一个为1的时候，结果才是1！

 3 ^ 4

   0 0 0 0 0 0 1 1 

^  0 0 0 0 0 1 0 0

————————-

   0 0 0 0 0 1 1 1

2 ^ 3

   0 0 0 0 0 0 1 1 

^  0 0 0 0 0 0 1 0 

———————

   0 0 0 0 0 0 0 1 

04.按位取反  ~ : 仅限于一个表达式运算

 ~ 3

~  0 0 0 0 0 0 1 1 

———————

   1 1 1 1 1 1 0 0    原码

   1 0 0 0 0 0 1 1    反码

   1 0 0 0 0 1 0 0    补码

———————–      -4

这是输出是补码操作

int a=-6;
        /**
         *     -6   的原码：1000 0110
         *            反码：1111 1001
         *            补码：1111 1010
         */
        //输出补码的方式
        for (int i=0;i<32;i++){
            //0x80000000--->二进制：1000 0000 0000 0000 0000 0000 0000 0000
            int t=(a&0x80000000>>>i)>>>(31-i);
            System.out.print(t);
        }

输出结果是：11111111111111111111111111111010

a、算数运算符：  +    -     *      /     %
b、赋值运算符： =    +=      -=       *=        /=       %=    &=     |=
c、关系运算符： <      >       <=      >=       ==        !=
d、逻辑运算符：&&    ||        !     
e、三目运算符：（  ？   ：）
f、字符串连接：+
g、位运算
                            &      位都为1，结果才为1，否则结果为0
                            |        位只要有一个为1，那么结果就是1，否则就为0
                            ^       两个操作数的位中，相同则结果为0，不同则结果为1
                            ~      如果位为0，结果是1，如果位为1，结果是0
h、移位：
                            <<     左移运算符，将运算符左边的对象向左移动运算符右边指定的位数（在低位补0）
                            >>    "有符号"右移运算符，将运算符左边的对象向右移动运算符右边指定的位数。使用
　　　　　　　　　　　　　　　　　　　　　　符号扩展机制，也就是说，如果值为正，则在高位补0，如果值为负，则
在高位补1.
                            >>>  "无符号"右移运算符，将运算符左边的对象向右移动运算符右边指定的位数。采
　　　　　　　　　　　　　　　　　　　　　　用0扩展机制，也就是说，无论值的正负，都在高位补0.
                            （PS：x<<y 相当于 x*2y ；x>>y相当于x/2y，从计算速度上讲，移位运算要比算术运算快。如果x是负数，
　　　　　　　　　　　　　　　　　　　　　　　　那么x>>>3没有什么算术意义，只有逻辑意义。）
运算符优先级：从左到右
      [ ]         ( )     ++      --        !       ～      instanceof      *       /       % 
      +        -        <<       >>          >>>        <      >       < =      > =       ==     
 !=      &     ^       &&      ||        ? :           op=