一文搞懂Java运算符

位运算符

1、按位与&，两者均为1才为1

2、按位或|，一者为1则为1

3、按位非~，取反，0变1，1变0

4、异或运算符^，相同为0，不同为1

5、左移运算符<<，符号位参与移动，移除高位，低位补0

​   移位效果：相当于num乘以2的n次方；移位足够大时，结果为其本身 0<<n=0

		System.out.println(8 << 0);       // 8
        System.out.println(8 << 100000);  // 8
        System.out.println(-8 << 0);      // -8
        System.out.println(-8 << 100000); // -8 

6、右移运算符>>，符号位不参与移动，移除低位，正数空位补0，负数空位补1

​   移位效果：相当于num除以2的n次方后，向下取整；移位足够大时，结果为其本身 0>>n=0

​        正数移位：2的n次方大于num，结果为0；负数移位：2的n次方大于|num|，结果为-1

 		System.out.println(7 >> 1);      //  3
        System.out.println(7 >> 100000); //  7
        System.out.println(-7 >> 1);     // -4
        System.out.println(-7 >> 100000);// -7
        System.out.println(8 >> 4);  //  0
        System.out.println(-8 >> 4); // -1 

7、无符号右移运算符>>>，符号位参与移动，移除低位，高位补0

​   移位效果：移位足够大时，结果为其本身 0>>>n=0

​        正数移位：无符号右移>>>和有符号右移>>，结果一样；负数移位：根据移位操作进行计算

System.out.println(8 >>> 100000);  //  8
System.out.println(-8 >>> 100000); // -8
System.out.println(7 >>> 2);  // 1
System.out.println(-7 >>> 2); // 0011 1111 1111 1111 1111 1111 1111 1110补 = 1073741822 

人脑使用原码进行计算，计算机使用补码进行计算

对操作数的二进制位进行运算，其操作数和结果都是十进制整数值

• 正数的原码、反码、补码相同
• 负数补码：反码+1
• 负数反码：除符号位其余各位按位取反

/*
 * 1   0000 0001补
 * -1  1111 1111补 1111 1110反 1000 0001原
 * */
int num1 = 1 & -1;
System.out.println("num1 = " + num1); // 0000 0001补 = 1

int num2 = 1 | -1;
System.out.println("num2 = " + num2); // 1111 1111补 1111 1110反 1000 0001原 = -1

int num3 = ~1;
System.out.println("num3 = " + num3); // 1111 1110补 1111 1101反 1000 0010原 = -2

int num4 = 1 ^ -1;
System.out.println("num4 = " + num4); // 1111 1110补 1111 1101反 1000 0010原 = -2

System.out.println(1 << 1); // 数字1左移1位  0000 0010补 = 2
System.out.println(-1 << 1);// 数字-1左移1位 1111 1110补 1111 1101反 1000 0010原 = -2

// 符号位不参与移动，正数空位补0，负数空位补1
System.out.println(1 >> 1); // 0000 0000补 = 0
System.out.println(-1 >> 1);// 1111 1111补 1111 1110反 1000 0001原 = -1

System.out.println(1 >>> 1); // 0000 0000补 = 0
System.out.println(-1 >>> 1);// 0111 1111 1111 1111 1111 1111 1111 1111补 = 2^31-1

一、&与&&、|与||

位运算符操作逻辑型数据时，位运算符不具有短路效果

• & ，按位与，全部是true才是true
• | ，按位或，有一个是true即为true
• ~ ，按位非~，取反，0变1，1变0

   		// 计算完表达式的值之后再给出结果
		int a = 10;
        System.out.println(false & ++a > 100);
        System.out.println("a目前的值：" + a); // 11
        System.out.println(true | ++a > 100);
        System.out.println("a目前的值：" + a); // 12

算术运算符

一、对于整数表达式才有： / 是整除，得到的是商 ；% 是取余，得到的是余数

        int var1 = 10 / 3;
        int var2 = 10 % 3;
        System.out.println("var1 = " + var1); // 3
        System.out.println("var2 = " + var2); // 1

        double var3 = 3.7 / 3;
        double var4 = 3.7 % 3;
        System.out.println("var3 = " + var3); // 1.2333333333333334
        System.out.println("var4 = " + var4); // 0.7000000000000002

二、不同类型的数据进行算术运算，结果的数据类型取范围大的

        int num1 = 10;
        float num2 = 10F;
        float result1 = num1 / num2; // 1.0     

三、 byte/short/char，参与算术运算时，自动提升为int类型

  		short num3 = 10;
        char num4 = 'a'; // 字母a的ASCII码为97
        int result2 = num3 + num4; // 107   

四、一元操作符（-）可以改变数字的正负号，对应的也有一元操作符（+）

		byte b = 1;
		int i = -b; // -1  byte自动提升为int

五、任何数据类型和字符串拼接，结果都是字符串类型

​ 使用并置符号“+”将变量、表达式或一个常量值与一个字符串并置一起输出

		String s = "java";
        System.out.println(s + 20); // java20
        System.out.println(s + 20 + 30); // java2030
        System.out.println(s + (20 + 30)); // java50 使用小括号改变运算优先级，优先级最高

赋值运算符

基本赋值运算符：=

复合赋值运算符：+= -= *= /= %=
​
       +=  a += 3  相等于  a = a + 3

​        -=  a -= 3  相等于  a = a - 3

​        *=  a *= 3  相等于  a = a * 3

​        /=  a /= 3  相等于  a = a / 3

​        %=  a %=3  相等于  a = a % 3

        int num1 = 1;
        num1 += 3;
        System.out.println(num1);//4
        int num2 = 10;
        num2 %= 3;
        System.out.println(num2);//1

• 赋值运算符左边的操作元必须是变量，不能是常量或表达式

		int i1 = 0;
		System.out.println(i1); // 0
		int i2 = i1 = 100;
		System.out.println(i2 + " " + i1); // 100 100

• 复合赋值运算符中隐含强制类型转换！

		byte b = 1;
		b += 3;//byte + int --> 强转为byte
		System.out.println(b);//4

		int i = 1;
		i += 3.0;//int + double --> 强转为int
		System.out.println(i);//4

关系运算符

一共有6种：> >= < <= == !=

关系运算符的结果是boolean值，true或false

基本数据类型本质上分为两大类：数值型、布尔型

数值型：整型，浮点型、字符型（字符和数字存在一一对应的关系，字符集）

		System.out.println(10 == 10.0);//true
		System.out.println(65 != 'A'); //true

• 如果进行多次判断，代码中不能连着写，1<x<3 ✖

		int x = 2;
		// System.out.println(1 < x < 3); // 标红报错
		System.out.println(1 < x && x < 3); // true

• 两边类型不一致时，自动转换为相同类型（范围大的），然后进行比较

  		int num1 = 10;
        double num2 = 10.1;
        System.out.println(num1 > num2); // false

• 比较 float 型数据与 double 型数据时，必须注意数据的实际精度

  float精度为7位，double精度为15位，存储小数，尽量使用double，float容易精度缺失

		float x1 = 0.4F;
        double y1 = 0.4; // 0.4D = 0.0 1100 1100 ...B
        System.out.println(x1 == y1); // false
        System.out.println(x1 > y1);  // true
		// 实际存储在变量 x1 中的数据是0.4000 0000 5960 4645  保留8位有效数字
		// 实际存储在变量 y1 中的数据是0.4000 0000 0000 0000  保留16位有效数字

        float x2 = 0.5F;
        double y2 = 0.5; // 0.5D = 0.1B
        System.out.println(x2 == y2); // true
        // 数据在计算机中都是以二进制形式存放   
		// 二进制表示小数（乘2取整，顺序排列），乘2有时不能消除小数部分，算法无限循环，表示不精确

逻辑运算符

&&，逻辑与，全部是true才是true

||，逻辑或，有一个是true即为true

！，逻辑非，取反，0变1，1变0

一、逻辑运算符的操作元必须是boolean型数据，用来连接关系表达式

		System.out.println(!true);//fasle  
        System.out.println(3 > 2 && 2 > 1);//true

二、“&&”和“||”具有短路效果

​ 根据逻辑运算符左边的表达式即可判断最终结果，那么右边的表达式将不再执行，从而提高一定的性能

 		int a = 10;
        System.out.println(a > 20 && ++a < 100);
        System.out.println(a);//10，前边为false，没有进行后面的++a操作

        int b = 20;
        System.out.println(b > 10 || ++b < 100);
        System.out.println(b);//20，前边为true，没有进行后面的++b操作

条件运算符

格式：数据类型 变量名 = 条件判断 ? 表达式A : 表达式B

流程：首先判断条件是否成立，成立则将表达式A的值赋值给左侧变量，反之则将表达式B的值赋值给左侧变量

一、三元运算符是二者选其一，等效于if-else语句

		int a = 10;
		int b = 20;
		int max = a > b ? a : b;
		System.out.println(max); // 20

二、必须同时保证表达式A和表达式B满足左侧的数据类型要求

		double res = 3 > 4 ? 3.0 : 4;
		System.out.println(3 > 4 ? 3.0 : 4); // 4.0

自增/减运算符

一、单独使用时，前++和后++没有任何区别

        int num = 1;
        num++;
        System.out.println(num);//2
        ++num;
        System.out.println(num);//3

二、混合使用时，如和打印、赋值等操作一起使用，有区别

​   前++是数值先+1，然后拿着结果用

​   后++是拿着数值本身的值来用，然后再将该数+1

​   无论如何，该加总会加，该减总会减，区别就是先加再用 / 先用再加

 		int x = 10;
        int y = 20;
        int result1 = ++x + y--;
        System.out.println(result1);//31
        System.out.println(x);//11
        System.out.println(y);//19

		// b-- 6   5   4   3   2   1   0
		// b   5   4   3   2   1   0  -1
		// a   0  -1  -2  -3  -4  -5
   		int a = 1, b = 6;
        while (b-- > 0) { // 和关系运算符号混合使用
            a--; // 单独使用
        }
        System.out.println(a + " " + b); // -5 -1

• 常量不可改变，不能使用自增自减运算符，只有变量可以

 		// 30++;// 标红报错

• byte/short/char，自增自减运算时，不会自动提升为int

		char c = 'A';
		char c1 = ++c;// B

instanceof运算符

Java独有的双目运算符，左面的操作元是对象，右面的操作元是类

当左面的对象是右面的类或其子类创建的对象时，结果为true，反之为false

 		// D extends C extends B extends A
		C c = new C();
        System.out.println(c instanceof A); // true
        System.out.println(c instanceof B); // true
		System.out.println(c instanceof C); // true
        System.out.println(c instanceof D); // false

null，空常量，Java的六种常量之一，引用类型的默认值，不是任何类的实例

		if (!(null instanceof Object)) {
            System.out.println("test..."); // test...
        }