Java运算符知多少

Java运算符知多少 一、运算符概念

运算符：对常量或者变量进行操作的符号，例如：+、-、< 等都是运算符。当然不同运算符对数据进行操作时，具有不同的含义。

Java中运算符可分为：算术运算符、关系运算符、逻辑运算符、位运算符、移位运算符、条件运算符、字符串连接运算符等。

二、算术运算符 1、四则运算符

基本四则运算符包括+ - * / %(加减乘除模)

四则运算符都属于二元运算符，左右两边都必须要有操作数！！！

（1）加(+):（两个不同基本类型的数据之间进行+运算，编译器会自动将数据类型小的转化成数据类型大的）

public class test {
    public static void main(String[] args) {
        //基本运算符：+
        int a = 20;
        int b = 10;
        System.out.println(a + b);

        int c = 20;
        double d = 30.00;
        //c是int类型，d是double类型，在做加法运算时编译器进行隐式类型转换
        System.out.println(c + d);
    }
}

（2）减( - ):（与加法类似）

public class test {
    public static void main(String[] args) {
        //基本运算符： -
        int a = 20;
        int b = 10;
        System.out.println(b - a);

        int c = 20;
        double d = 30.00;
        System.out.println(d - c);
    }
}

（3）乘(*):

public class test {
    public static void main(String[] args) {
        //基本运算符： *
        int a = 20;
        int b = 10;
        System.out.println(a * b);

        int c = 20;
        double d = 30.00;
        System.out.println(c * d);
    }
}

（4）除(/):（做除法时例如int / int虽然没有进行类型转换，但是会向下取整，并且除的右操作数不能为0，否则会报算术异常代码崩溃）

public class test {
    public static void main(String[] args) {
        //基本运算符： /
        int a = 20;
        int b = 10;
        System.out.println(a / b);

        int c = 20;
        double d = 30.00;
        System.out.println(d / c);
    }
}

public class test {
    public static void main(String[] args) {
        //基本运算符： /
        int a = 20;
        int b = 0;
        //这里的右操作数b为0，测试一下会出现什么结果
        System.out.println(a / b);

        int c = 20;
        double d = 30.00;
        System.out.println(d / c);
    }
}

可以看见当右操作数为0时，报出了右操作数为0的算术异常，代码崩溃并且后续代码不执行

（5）模(%):

public class test {
    public static void main(String[] args) {
        //基本运算符： %
        int a = 20;
        int b = 3;
        System.out.println(a % b);

        double c = 2.0;
        double d = 11.5;
        //在Java中，不仅整型数据可以取模，double和float类型数据也可以取模
        System.out.println(d % c);
    }
}

Java中的取模运算相当于数学中的的求余数，当然模数（右操作数）也不能为0，否则会报算数异常

public class test {
    public static void main(String[] args) {
        //基本运算符： -
        int a = 20;
        int b = 0;
        System.out.println(a % b);
    }
}

2、增量运算符

增量运算符包括+= -+ *= /= %=（注意：增量运算符只能变量使用，常量不可用）

public class test {
    public static void main(String[] args) {
        //增量运算符：+=  -=  *=  /=  %=
        //增量运算符只能对于变量使用，不可以应用在常量上
        int a = 5;
        a += 1;//等价于a=a+1  6
        System.out.println(a);

        a -= 1;//等价于a = a - 1   5
        System.out.println(a);

        a *= 2;//等价于a = a * 2  10
        System.out.println(a);

        a /= 2;//等价于a = a / 2    5
        System.out.println(a);

        a %= 3;//等价于a = a % 3   2
        System.out.println(a);
    }
}

特殊说明：用final修饰的定义的常量也不可以进行增量运算。该常量进行增量运算时不能通过编译，代码飘红

在C语言中可以用const来定义不能修改的变量，但是在Java中const是Java的保留字而不是关键字，所以不能用const定义不能修改的变量，而是用final来定义不能修改的变量

3、自增/自减运算符

自增自减运算符包括 ++ --(又分为前置++，后置++，前置–，后置–)

public class test {
    public static void main(String[] args) {
        //自增/自减运算符：++   --
        int a = 10;
        a++;//后置++  11
        System.out.println(a);
        //先使用后加1
        int ret = a++;
        System.out.println(a);//12
        System.out.println(ret);//11

        //前置++  先加1后使用
        ret = ++a;//13
        System.out.println(a);//13
        System.out.println(ret);![在这里插入图片描述](https://img-blog.csdnimg.cn/db5edd0ac11f4e1ca157b9ce7b68dbbd.png#pic_center)

        
    }
}

注意：前置++ 和后置++在单独使用时并没有什么不同。只是混合使用时，前置++是变量先加再使用其值，后置++是先使用变量原来的值再运算结束后变量再加。同样该运算符只有变量可以使用（-- 与 ++ 用法相似，这里就不不举例了）

三、关系运算符

关系运算符有六个 == != < > <= >=

关系运算符的结果是boolean类型的，只能为true或者false

public class test {
    public static void main(String[] args) {
        //关系运算符  <  >  ==  !=  <=  >=
        int a = 3;
        int b = 5;
        System.out.println(a < b);//true
        System.out.println(a > b);//false
        System.out.println(a == b);//false
        System.out.println(a != b);//true
        System.out.println(a >= b);//false
        System.out.println(a <= b);//true
        //注意：需要多次判断时不能连着写，例如3
    }
}

要使用关系运算符进行多次判断时，不能像数学中一样连起来写，只能分开判断用&&连接

四、逻辑运算符！！！

逻辑运算符主要有三个:逻辑与(&&)、逻辑或(||)、逻辑非(!),，结果也为boolean类型，只有true和false两种情况（&& 和 ||为二元运算符，！为一元运算符）

（1）逻辑与&&：表达式1 && 表达式2，两个表达式都必须为boolean类型结果（有假则假，全真则真）

表达式1	表达式2	结果
true	true	true
true	false	false
false	true	false
false	false	false

public class test {
    public static void main(String[] args) {
        //逻辑运算符  &&  ||  ！ 运算结果都是boolean类型
        int a = 10;
        int b = 20;
        //编译失败，因为表达式1 && 表达式2 时，表达式1和表达式2只能是boolean类型，而a和b是整型数据
        //System.out.println(a && b);
        System.out.println(a != 10 && b != 20);//false && false =  false
        System.out.println(a != 10 && b == 20);//false && true  =  false
        System.out.println(a == 10 && b != 20);//true && false  =  false
        System.out.println(a == 10 && b == 20);//true && true   =  true
    }
}

表达式1和表达式2必须为boolean类型结果，否则代码会飘红，编译失败

（2）逻辑或||：表达式1 || 表达式2（有真则真，全假则假）

表达式1	表达2	结果
true	true	true
true	false	true
false	true	true
false	false	false

public class test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a != 10 || b != 20);//false || false = false
        System.out.println(a == 10 || b != 20);//true || false = true
        System.out.println(a != 10 || b == 20);//false || true = true
        System.out.println(a == 10 || b == 20);//true || true = true
    }
}

（3）逻辑非(!)：！表达式（只需要一个表达式，真变假假变真）

表达式	结果
true	false
false	true

在使用&& 与 ||运算符时，遵循短路求值规则（即对于&&，表达式1若为false则结果一定为false，表达式2就不会被计算；对于||，若表达式1为true，则结果一定为true，表达式2就不会被计算）

public class test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //&& 和 || 运算遵循短路求值规则
        //第一个表达式已经为假，进行&&操作时第二个表达式不参与运算，所以不报错
        System.out.println(a != 10 && 10 / 0 == 0);
        //第一个表达式已经为真，进行||操作时第二个表达式不参与运算，则不会报错
        System.out.println(a == 10 || 10 / 0 == 0);
    }
}

五、位运算符

位运算符主要有& | ~ ^(按位与，按位或，按位取反，按位异或)，位运算表示按二进制运算，必须先把其转换为二进制才可以运算

（1）&（按位与）：二进制中都为1则为1，否则为0。以下展示按位与具体操作

（2）|（按位或）：两个二进制都为0才为0，否则结果为1

（3）~（按位取反）：如果该位为0则转为1，为1则转为0

补充知识：整数在内存中以补码形式存在：

• 原码 反码 补码

• 正数的原码、反码、补码相同

​ 原码：数据的二进制格式

​ 反码：原码取反

​ 补码：反码 + 1

• 负数的原、反、补码都是不同的

• 知道一个负数存储时的补码，要还原：

​ 先将补码减一，再除符号位不变，其他位取反

​ 例： 1111 1111 1111 1111 1111 1111 1111 0101

​ 先减一：1111 1111 1111 1111 1111 1111 1111 0100

​ 再取反：1000 0000 0000 0000 0000 0000 0000 1011 -11

（4）^（按位异或）：相同则为0，不同则为1

public class test {
    public static void main(String[] args) {
        int a = 10;//0000 1010
        int b = 20;//0001 0100
        System.out.println(a & b);//按位与操作后：0000 0000
        System.out.println(a | b);//按位或操作后：0001 1110
        System.out.println("-----------------------");

        //按位异或^
        int c = 0x55555555;
        int d = 0xAAAAAAAA;
        int e = c;
        System.out.println(c ^ d);
        System.out.println(c ^ e);//当两个相同的数进行按位异或时，结果为0  例如：10 ^ 10 = 0
    }
}

六、移位运算符

移位运算符包括三种：<< >> >>>（都是二元运算符且都是按照二进制计算）

（1）<<（左移）：最左侧不要，右侧补0（左移n位相当于乘以2^n，最左侧高位位符号位，所以正数左移舍弃符号位可能变成负数）

（2）>>（右移）：最右侧不要，最左侧补符号位（正数符号位为0，负数符号位为1，右移n位相当于除以2^n）

（3）>>>（无符号右移）：最右侧不要，最左侧补0（不管正数负数最左侧都补0，所以称为无符号右移）

public class test {
    public static void main(String[] args) {
        //移位运算
        int a = 10;
        //左移<>n  最低n位丢弃，最高n位补符号位
        System.out.println(a >> 1);//5  a右移n位相当于a除以2^n
        System.out.println(a >> 2);//2
        //无符号右移 >>>n   最高位补0，最低位丢弃(不管正负数最高位都补0)
        System.out.println(a >>> 1);//5
    }
}

移位运算的效率高于使用2^n的效率，所以在今后出现乘2的n次方和除2的n次方时就可使用移位运算代替

例如计算a+b的平均值，用(a+b)/2肯会导致溢出

由于在计算时计算机不知道a和b的值，若a和b都为特别大的数，所以a+b的值可能会超过整型数据的取值范围，导致a与b的和溢出，出现程序不安全现象。可以将b比a多出部分分一半给a，这样就不会导致溢出。则优化的式子：a+(b-a)/2。由于移位运算符的效率高于除法，则可进一步优化成a+((b-a)>>1).

七、条件运算符

条件运算符只有一个：表达式1？表达式2：表达式3

运算规则为：若表达式1为真则执行表达式2，若表达式1为假则执行表达式3；且表达式1一定为boolean结果，表达式2和表达式3的类型要相同。该条件运算符时Java中唯一的一个三目运算符。

public class test {
    public static void main(String[] args) {
        //条件运算符  表达式1 ？ 表达式2 ： 表达式3
        int a = 10;
        int b = 20;
        //三目运算符不能单独被使用，得出的结果必须要被使用
        //表达式1一定是boolean类型的结果，表达式二和表达式三的类型要相同
        //int ret1 = a ? a : b;
        //int ret2 = a > b ? a : true;
        int ret = a > b ? a : b;
        System.out.println(ret);
    }
}

八、字符串拼接运算符

字符串拼接的运算符为+。当使用该运算符时，只要左右两边任意有一个操作数为字符串类型时，则进行字符串拼接运算，当字符串拼接完成后仍然为字符串类型；只有两边都为基本类型时才是做加运算。

public class test {
    public static void main(String[] args) {
        //字符串拼接 +
        String s1 = "abc";
        String s2 = "efg";
        int a = 123;
        int b = 456;
        System.out.println(s1 + s2);//两个字符串拼接结果为字符串
        System.out.println(s1 + a);//字符串与数值拼接结果为字符串
        System.out.println(a + b);//两个数值+为加运算
        System.out.println(a + s1);
    }
}

九、运算符优先级

​ 运算符之间是有优先级的，在表达式混合用时更能体现出优先级（建议在有多个运算符时采用()控制优先级，以免出错）

public class test {
    public static void main(String[] args) {
        //运算符的优先级
        int a = 10;
        int b = 20;
        //求a与b的和的平均值
        //运算符的优先级有高有低，可以根据（）来调节运算顺序
        int avg = (a + b) / 2;//可能会有溢出
        System.out.println(avg);
        // +的优先级高于移位运算符，所以该式子先加后移位，导致结果错误
        avg = a + (b - a) >> 1;
        System.out.println(avg);
        //用（）来调节运算顺序
        avg = a + ((b - a) >> 1);
        System.out.println(avg);
    }
}