Java 运算符

运算出计算机的基础功能之一, 所以每种编程语言都有自己的运算方式, 也都有自己的运算符, 来完成各种类型的 变量, 常量, 表达式 等之间的运算. 安装运算的类型分类 Java 中的运算符分为:

  1. 算术运算符
  2. 比较运算符
  3. 逻辑运算符
  4. 位运算符
  5. 赋值运算符
  6. 其他运算符

 

共计 6 种, 以下, 我们将一一道来.

1. 算术运算符

算数运算符应用于算数运算中, 符号也与我们在数学中的符号类似.

1.1 常见的算数运算符

运算符 说明 举例与结果
+ 加法计算, 计算运算符左右两边值的和 1 + 2 = 3
- 减法计算, 计算运算符左右两边值的差 55 - 7 = 48
* 乘法计算, 计算运算符左右两边值的积,相当于数学中的 × 21 * 7.2 = 151.20000000000002
/ 除法计算, 计算运算符左值除以右值的商, 相当于数学中的 ÷ 21 / 3.0 = 7.0
% 取模计算, 计算运算符左值整除右值的余数 21 % 3.0=0.0, 21 % 3 = 0

从上面的表格示例中我们可以发现, 不同基础类型的数字之间是可以做相同的算数运算的, 比如 21 / 3.0 得数也会最小限度的向上实现容量兼容, 所以结果是 7.0, 因为双精度实型的容量更大, 具体参见 Java 的技术数据类型 隐式转换的部分. 同时我们发现 21 * 7.2 不是等于 151.2, 这个属于 Java 中浮点计算的精度丢失, 成因及如何解决请移步这里.

1.2 自增自减运算符

Java 中存在自增(++)和自减(--)的运算符号, 所谓自增(减)是指一个变量通过符号参与运算后, 增加(减少)了变量自身的值.

以下是一段实例代码:

class Yi21Runner {
    public static void main(String[] args) {
        int i = 100;
        //前置自减, 值发生了变化且表达式的结果 也发生了 变化
        System.out.println(--i);
        //自减后的值
        System.out.println(i);
        i = 100;
        //后置自减, 值发生了变化但表达式的结果 不发生 变化
        System.out.println(i--);
        //自减后的值实际上是发生了变化的
        System.out.println(i);
    }
}

在上述代码中

我们先声明了一个 int 型的变量值为 100 , 首先我们对其做了前置自减操作, --i 就是个前置自减表达式, 这时候表达式返回的值就变成 99,

然后我们再次将变量的值, 赋值为 100, 然后我们对其做了后置自减操作, i-- 就是一个后置自减表达式,  这时候表达式的返回值仍然是100,

怎么理解这个差异呢? 很简单, 无论是 --i 还是 i--, 他们都是表达式, 表达式完成计算返回了一个值, 表达式不是变量本身, 仅此而已.

同理可推到自增符号上.

2. 比较运算符

比较运算符, 用于比较两个值得的大小, 符号与数学运算也类似, 比较运算表达式的范围值为 boolean 型, 表示真(true)或者假(false):

运算符 说明 举例与结果
== 等于比较, 计算表达式两边的值是否相等 1 == 1.0 (true), 1==1.1 (false)
!= 不等比较, 计算表达式两边的值是否不相等 1 != 1.1(true), 1 != 1.0 (false)
> 大于, 计算表达式左边的值是否大于右边 55 > 7 (true), 2.0 > 2 (false)
>= 大于或等于, 计算表达式左边的值是否大于或等于右边, 相当于数学中的 ≥ 2 >= 2.0 (true), 5 >= 6 (false)
< 小于, 计算表达式左边的值是否小于右边 5 < 99 (true), 5.0 < 5 (false)
<= 小于或等于, 计算表达式左边的值是否小于或等于右边, 相当于数学中的 ≤ 4 <= 4.0 (true) 6 <= 5.0 (false)

3. 逻辑运算符

逻辑运算符是用来描述 , , 等逻辑关系的运算符, 与数学中的学到的逻辑关系一致.

运算符 说明 举例与结果
&& 逻辑与(AND), 运算符两边的值同为真(true)才为真, 否则为假(false) true && true (true), true && false (false)
|| 逻辑或(OR), 运算符两边的值同为假(false)才为假, 否则为真(true) false || false (false), false || true (true)
! 逻辑非(NOT), 运算符右侧的值: 为假, 则表达式的值为真;为真,则表达式的值为假 !true (false), !false (true)

 

4. 位运算符

位运算符是对 byte, short, int, long, char 值的二进制值进行位运算的运算符, 位运算就是对二进制的每一位进行位的运算, 位运算符有如下:

注: 下表的说明中的位上是指计算的值之间的二进制值上的的位置, 二进制不足的的位数用0补齐, 比如 1 和 0 做位运算就是 0b10 和 0b00 做位运算, 相同的位置就是从右向左数相同的第几位.

运算符 说明 举例与结果
& 位与(AND), 位上均为1则为1, 否则为0

16 & 7 => 0b10000 & 0b00111 => 0b00000 => 0

7 & 5 => 0b111 & 0b101 => 0b101 => 5

| 位或(OR), 位上有1则为1, 否则为0

16 | 7 => 0b10000 | 0b00111 => 0b10111 => 23

7 | 5 => 0b111 | 0b101 => 0b111 => 7

^ 位异或(XOR), 位上不同则为1, 否则为0.

17 ^ 7 => 0b10001 ^ 0b00111 => 0b10110 => 22

7 ^ 4 => 0b111 ^ 0b100 => 0b011 => 3

~

位非(NOT), 二进制值取反码, +1

相当于原值 +1后取反

~16 => ~0b10000 => -0b10001 => -17

~7 => ~0b111 => 0b1000 => -8

<< 位左移计算, A<<X, A的二进制值向左移动X位

64 << 1 => 0b1000000 << 1 => 0b10000000 => 128

63 << 1 => 0b111111 << 1 => 0b1111110 => 126

>> 位右移计算, B>>Y, B的二进制值向右移动Y位

63 >> 1 => 0b111111 >> 1 => 0b11111 => 31

62 >> 1 => 0b111110 >> 1 => 0b11111 => 31

>>>

无符号位右移计算, C>>>Z, C 的二进制值无符号向右移动Z位:

高位补码后 进行位向右移动 Z 位的计算

63 >>> 1 => 0b111111 >>> 1 => 0b11111 => 31

-63 >>> 1 => -0b111111 >>> 1 => 0b1111111111111111111111111100000 => 2147483643

5. 赋值运算符

运算符 说明
= 将等号右边值赋值给左边的变量
+= 变量等于变量当前值加上等号右边的值
-= 变量等于变量当前值减去-等号右边的值
*= 变量等于变量当前值乘以等号右边的值
/= 变量等于变量当前值除以等号右边的值
%= 变量等于变量当前值对等号右边的值取模
<<= 变量等于变量当前值做等号右边位数的左移位运算
>>= 变量等于变量当前值做等号右边位数的右移位运算
&= 变量等于变量当前值对等号右边的值做位与运算
|= 变量等于变量当前值对等号右边的值做位或运算
^= 变量等于变量当前值对等号右边的值做位异或运算

6. 其他运算符

6.1 条件运算符 (?:)

条件运算符又成为三元运算符, 它是一种通过满足一定条件返回不同值的表达式的符号组合, 三元表达式写法如下:

条件? 条件为真的结果: 条件不为真的结果

示例如下:

class Yi21Runner {
    public static void main(String[] args) {
        double bmi = 35;
        String description = bmi > 30? "肥胖": "不肥胖";
        System.out.println(description);
    }
}

上面的代码中, 通过判断 bmi 来给描述 description 赋值, bmi 大于 30的就是肥胖, 因此本代码会输出"肥胖"

6.2 instanceof 运算符

instanceof 运算符用于检测对象引用变量是否为特定类型(类或接口), 语法如下:

变量 instanceof 类名 / 接口名

该运算符返回一个布尔值, true / false 表示是否成立, 实例:

class Yi21Runner {
    public static void main(String[] args) {
        String hello = "Hello World.";
        if (hello instanceof String) {
            System.out.println("是字符串");
        } else {
            System.out.println("不是字符串");
        }
    }
}

上述代码输出: "是字符串"

以上就是 Java 中的运算符的全部内容了.

如果不同运算符混用, 那么应该如何运算, 又有怎样的规则呢, 还请移步Java 中运算符的优先级

如果已经有所了解, 即可进入下一章: Java 的条件控制语句