数学运算符、逻辑运算符、位运算符小结

运算符

数学运算符

+ - * /  % ++ --

其中-与*与数学中的效果是一样的

+符号

如果两边都是数字，则做数学运算；如果+的左边或者右边是字符串，则起到拼接字符串

int a = 5;
        int b = 6;
        //如果+两边都是数字，则做数学运算(与数学中的效果是一样的)
        System.out.println(a + b);//11

        int c = 7;
        String s = "hello";
        System.out.println(c + s);//"7hello"

        System.out.println(c + b + s + b + c);//"13hello67"

变量参与+的数学运算问题（自动的类型提升）

在运算中如果直接使用变量，则java会自动的做类型提升， byte short char 都会被自动的提升为int

byte b1 = 3;
        byte b2 = 4;
        /*
        在运算中如果直接使用变量，则java会自动的做类型提升
        byte short char 都会被自动的提升为int
         */
       // byte b3 = b1 + b2;//会出错
        byte b3 = (byte)(b1 + b2);
        byte b34 = 3 + 4;//如果是字面量做数学运算，就不需要强转

自增与自减

++自增

• –自减
  自增/自减表达式本身的值

++a:先自增,再赋值
a++:先赋值,再自增

自增：将a变量的值+1
赋值：将a变量的值赋给表达式

a–:先赋值，再自减
–a:先自减，再赋值

 int a = 5;//6
        System.out.println(a++);//5
        System.out.println(a);//6


        int b = 5;//6
        System.out.println(++b);//6
        System.out.println(b);//6

        int c = 5;//6 7
        System.out.println(c++ + ++c);//12
        //                  5     7

        int e = 5;//6  5
        int f = 6;//5  6
        System.out.println(e++ - --f + f++ - --e);//0
        //                 5     5      5     5
        System.out.println(e + ":" + f);//5:6


        int g = 5;//6 5
        //赋值的过程：将右边的值赋值给左边的变量
        g = g++;
        //   5
        System.out.println(g);//5

/符号

结果值的类型与 除数与被除数中长度最大的类型 一致
如果结果值应该是整型，但是真实的结果是浮点型。 java就会将真实的浮点型结果转换成整型

 		System.out.println(4/3);//1
        System.out.println(5/2.0);//2.5
        System.out.println(5.0/2);//2.5

%取余符号

//求10除以3的余数
        System.out.println(10%3);//1
        //求3除以10的余数
        System.out.println(3%10);//3

逻辑运算符（& && | || ! ^）

&与&&

逻辑与符号的使用：&
相当于生活中说的并且。

boolean表达式1&boolean表达式2
boolean值1&boolean值2

boolean表达式：得到的结果一定是boolean值
特点：左右两边都是true的时候，整个表达式的结果就是true. 否则都是false

&& :基本使用与&是一致的
特点：左右两边都是true的时候，整个表达式的结果就是true. 否则都是false
与&的区别：
&&有短路的效果：如果判断出左边的表达式值为false,则不用判断右边的值，而直接给出整体的结果为false

int a = 5;
        int b = 6;
        //左边的表达式值为true 右边的表达式值为true,所以整体的结果为true
        System.out.println((a++ == 5) & (++b == 7));//true
        //左边的表达式值为true 右边的表达式值为flase,所以整体的结果为false
        System.out.println((a == 6) & (b == 6));//false

        // 测试&& 的基本使用与 & 结果是一致的
        int c = 5;
        int d = 6;
        System.out.println((c++ == 5) && (++d == 7));//true


        //测试&没有短路效果
        int a2 = 5;
        int b2 = 6;//7
        System.out.println((a2 == 6)&(b2++ == 6));//false
        /*
        打印表b2的值为7,说明上面的表达式中了判断右边的表达式，说明没有短路效果
         */
        System.out.println(b2);//7

        int c2 = 5;
        int d2 = 6;
        System.out.println((c2 == 6)&&(d2++ == 6));//false
        /*
        打印d2的值为6,说明上面的表达式中没有判断右边的表达式，说明短路效果确实有效
         */
        System.out.println(d2);//6

|与||

逻辑|与||符号的使用
就是与生活中中的或者是一个意思
特点：符号连接的表达式中只要有一个结果为true,则整体的结果为true

| 与 || 的区别：
||有短路效果：
如果左边的结果为true,则不用再判断右边的表达式了

		int a = 5;
        int b = 6;
        int c = 6;
        System.out.println((a == 5) | (b == 7));//true


        System.out.println((a == 5)|(c++ == 6));//true
        //| 没有短路效果，所以要判断右边的表达式，c的值有自增一次
        System.out.println(c);//7
        System.out.println((a == 5)||(b++ == 6));//true
        //|| 有短路效果，所以不会判断右边的表达式，b的值不会发生变化
        System.out.println(b);//6

!^

!:取反
用法：!boolean表达式
作用：结果为boolean表达式相反的值

^：异或（了解）
用法：boolean表达式1^boolean表达式2
特点：左边的表达式的值 与 右边的表达式的值，如果相同，则整个表达式的值就是false,否则就是true

		int a = 5;
        int b = 6;
        // a==b 不成立，结果值为false，加上!之后，结果就取反，就变成了true
        System.out.println(!(a == b));//true
        System.out.println(!(a < b));//false

        System.out.println((a < b)^(a > b));//true
        System.out.println((a < b)^(b > a));//false

位运算符（& | ^ >> << >>>）

& | ^ 写法与逻辑运算符是一致的
如果运算符两边是boolean表达式的话，则符号的作用是逻辑运算符
如果运算符两边是数字的话，则符号的作用是位运算符

& |&

& | ^ 位运算符的使用
可以将1看做true,可以将0看做false

 &:两个都是1，则结果为1，否则为0
 |：只要有一个为1，则结果为1，否则为0
 ^:两个值不同，则结果为1，否则为0

//这里用int类型举例 其他类型只是位数不同，运算方式都一样
& 做位运算符的时候,运算方式：
        将两个数字都转换为二进制
        3:00000000 00000000 00000000 00000011
        2:00000000 00000000 00000000 00000010
        ---------------------------------------
          00000000 00000000 00000000 00000010                                
         */
        System.out.println(3 & 2);//2

        /*
        3:00000000 00000000 00000000 00000011
        2:00000000 00000000 00000000 00000010
        ---------------------------------------
          00000000 00000000 00000000 00000011
         */
        System.out.println(3 | 2);//3
        /*
         3:00000000 00000000 00000000 00000011
         2:00000000 00000000 00000000 00000010
         --------------------------------------
           00000000 00000000 00000000 00000001
         */
        System.out.println(3 ^ 2);//1

>> << >>>

<<：左位移

将数字的二进制形式向左移动指定的位数，右方补0

		/*
		2:00000000 00000000 00000000 00000010    位移之前
          00000000 00000000 00000000 00010000   位移之后
         */
         //符号前表示要移动的数，符号后面表示要移动几位
        System.out.println(2 << 3);//16

>>：右位移

将数字的二进制形式向右移动指定的位数，
左边的首位如果是1，则在左方补1
左边的首位如果是0，则在左方补0

/*
		24:00000000 00000000 00000000 00011000  位移之前
           00000000 00000000 00000000 00000011  位移之后
*/		
		System.out.println(24 >> 3);//3
        System.out.println(-24 >> 3);//-3

>>>：无符号右位移

将数字的二进制形式向右移动指定的位数，无论左边的首位是1还是0，都在左方补0

/*
		-24原码：10000000 00000000 00000000 00011000
        -24的反码：11111111 11111111 11111111 11100111
        -24的补码：11111111 11111111 11111111 11101000
        位移之后： 00011111 11111111 11111111 11111101
*/
		System.out.println(-24 >>> 3);//536870909