运算符

运算符

除号

public class Test{
    public static void main(String[] args){
        int num1 = 12;
        int num2 = 5;
        int result1 = num1 / num2;
        System.out.println(result1);//2
        
        int result2 = num1 / num2 * num2;
        System.out.println(result2);//10
        
        double result3 = num1 / num2;
        System.out.println(result);//2.0
        
        double result4 = num1 / num2 + 0.0;//2.0
        double result5 = num1 / (num2 + 0.0);//2.4
        double result3 = (double)num1 / num2;//2.4
        double result3 = (double)(num1 / num2);//2.0
    }
}

取余

       //结果的符号与被模数相同
		int m1 = 12;//被模数
		int n1 = 5;//模数
		System.out.println("m1 % n1 = " + m1 % n1);//2

		int m1 = -12;
		int n1 = 5;
		System.out.println("m1 % n1 = " + m1 % n1);//-2

		int m1 = 12;
		int n1 = -5;
		System.out.println("m1 % n1 = " + m1 % n1);//2

		int m1 = -12;
		int n1 = -5;
		System.out.println("m1 % n1 = " + m1 % n1);//-2

自增/减

		int a1 = 10;
		int b1 = ++a1;
		System.out.println("a = " + a1",b1 = " + b1);//11 11

		int a2 = 10;
		int b2 = a2++;
		System.out.println("a2 = " + a2",b2 = " + b2);//11 10
		
		short s1 = 10;
		s1 = s1 + 1;//编译失败
		s1 = (short)(s1 + 1);//编译正确
		s1++;//自增1不会改变变量本身的数据类型
		System.out.println(s1);

赋值运算符

		short s1 = 10;
		s1 = s1 + 2;//编译失败
		s1 += 2;//不会改变变量本身的数据类型
		System.out.println(s1);

		//让变量实现+2的操作(int num = 10;)
		//方式一：num = num + 2;
		//方式二：num += 2;

逻辑运算符

逻辑运算符操作的都是boolean类型的变量

• a^b：异或，相同为0，不同为1

• a&b,a&&b:

  相同点：

​ & 与 && 的运算结果相同

​ 当符号左边是true时，二者都会执行符号右边的运算

​ 不同点：当符号左边是false时，&继续执行符号右边的运算，&& 不再执行符号右边的运算

​ 更常用&&

public class LogistTest{
    public static void main(String[] args){
        boolean b1 = false;
        int num1 = 10;
        if(b1 & (num1++ > 0)){
            System.out.println("111111111");
        }else{
            System.out.println("222222222");
        }
        System.out.println("num1 = " + num1);
        /*222222222222222222
          num1 = 11
        */
        
        boolean b2 = false;
        int num2 = 10;
        if(b2 && (num2++ > 0)){
            System.out.println("111111111");
        }else{
            System.out.println("222222222");
        }
        System.out.println("num2 = " + num2);
        /*222222222222222222
          num2 = 10
    	*/
    }
}

• a|b,a||b：

  相同点：

  ​ & 与 && 的运算结果相同

  ​ 当符号左边是true时，二者都会执行符号右边的运算

  不同点：当符号左边是false时，&继续执行符号右边的运算，&& 不再执行符号右边的运算

  更常用||

public class LogistTest{
    public static void main(String[] args){
        boolean b3 = true;
        int num3 = 10;
        if(b3 | (num3++ > 0)){
            System.out.println("111111111");
        }else{
            System.out.println("222222222");
        }
        System.out.println("num3 = " + num3);
        /*1111111111111111
          num3 = 11
        */
        
        boolean b4 = true;
        int num4 = 10;
        if(b4 || (num4++ > 0)){
            System.out.println("111111111");
        }else{
            System.out.println("222222222");
        }
        System.out.println("num4 = " + num4);
        /*11111111111111111
          num4 = 10
    	*/
    }
}

位运算符

位运算符	操作
< <	空位补0，被移除的高位丢弃，空缺位补0；
> >	被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1；
>>>	被移位二进制最高位无论是0或者是1，空缺位都用0补；
&	二进制位进行&运算，只有1&1时，结果是1，其余都是0；
|	二进制位进行|运算，只有0|0时，结果是0，其余都是1；
^	相同二进制位进行 ^ 运算，结果是0；不同二进制位进行 ^ 运算，结果是1；
~	正数取反，各二进制码按补码各位取反；负数取反，各二进制码按补码各位取反；

1. 位运算符操作的都是整形的数据

2. << : 在一定范围内，每向左移1位，相当于 * 2

   >> : 在一定范围内，每向右移1位，相当于 / 2

最高效的计算 2 * 8 ：2 << 3 或8 << 1

public class BitTest{
    public static void main(String[] args){
        int i = 1;
        
        System.out.println("i << 2 :" + (i << 2));
        System.out.println("i << 3 :" + (i << 3));
        System.out.println("i << 2 :" + (i << 2));
        
        int m = 12;
        int n = 5;
        System.out.println("m & n :" + (m & n));
        System.out.println("m | n :" + (m | n));
        System.out.println("m ^ n :" + (m ^ n));
     
        //练习：交换两个变量的值
     	int num1 = 10;
        int num2 = 20;
        System.out.println("num1 = " + num1 + ",num2 = " + num2);
        //方式一：
        int temp = num1;
        num1 = num2;
        num2 = temp;
        
        /*方式二：
        好处：无需定义临时变量
        弊端：相加操作可能超过存储范围
        	 有局限性:只能适用于数值类型
        */ 
        num1 = num1 + num2;
        num2 = num1 - num2;
        num1 = num1 - num2;
        
        //方式三：使用位运算符(k = m ^ n,m = k ^ n = (m ^ n) ^ n)
        num1 = num1 ^ num2;
        num2 = num1 ^ num2;
        num1 = num1 ^ num2;
        
        System.out.println("num1 = " + num1",num2 = " + bum2);      
    }
}

三元运算符

格式：（条件表达式值）？表达式1：表达式2：

• 条件表达式的结果为boolean类型
• 根据表达式真或假,决定执行表达式1,还是表达式2.若为true,执行表达式1;为false,执行表达式2.
• 表达式1和表达式2要求一致，可转化为同一类型.
• 三元运算符可以嵌套

class SanYuanTest{
    public static void main(String[] args){
        
        //获取两个整数的较大值
        int m = 12;
        int n = 5;
        
        int max = (m > n)? m : n;
        System.out.println(max);
        
        //(m > n)? 2 : "n大";编译错误
        
        String maxStr = (m > n)?"m大" : ((m == n)? "m和n相等" : "n大");
        System.out.println(maxStr);
        
        //获取三个数的最大值
        int n1 = 12;
        int n2 = 30;
        int n3 = -43;
       /* 
        int max1 = (n1 > n2)? n1 : n2;
        int max2 = (max1 > n3)? max1 : n3;
        System.out.println("三个数中的最大值为：" + max2);
        
        int max = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
        System.out.println("三个数中的最大值为：" + max);
        */

三元运算符和if-else的转换

（凡是可以使用三元运算符的地方，都可以改写为if-else；反之，不成立）

既可以用三元运算符，又可以用if-else，优先选择三元运算符，简洁，效率高

//求较大数改写为if-else
if(m > n){
    System.out.print(m);
}else{
    System.out.print(n);
}

运算符的优先级

早运算加（），只有单目运算符，三元运算符，赋值运算符是从右向左运算。