Java 运算符

目录

• 1.运算符和表达式
• 2.算术运算符
• • 2.1 字符的 `+` 操作
  • 2.2 字符串的 `+` 操作
• 3.自增自减运算符
• 4.赋值运算符
• 5.关系运算符
• 6.逻辑运算符
• 7.短路逻辑运算符
• 8.三元运算符
• 9.位运算符

1.运算符和表达式

运算符：对常量或者变量进行操作的符号。

表达式：用运算符把常量或者变量连接起来符合 Java 语法的式子就可以称为表达式。

不同运算符连接的表达式体现的是不同类型的表达式。

举例说明：

int a = 10;
int b = 20;
int c = a + b;

+：是运算符，并且是算术运算符。

a + b：是表达式，由于 + 是算术运算符，所以这个表达式叫算术表达式。

2.算术运算符

/ 和 % 的区别：两个数据做除法，/ 取结果的商，% 取结果的余数。

int a = 10;
int b = 3;
System.out.println(a / b); // 输出结果3
System.out.println(a % b); // 输出结果1

整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

System.out.println(10 / 2); // 输出结果5
System.out.println(10 / 3); // 输出结果3
System.out.println(10 / 3.0); // 输出结果3.3333333333333335
System.out.println(10.0 / 3); // 输出结果3.3333333333333335

2.1 字符的 + 操作

算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。

• byte、short、char类型将被提升到 int 类型，不管是否有其他类型参与运算。
• 整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型。
• 等级顺序：byte, short, char --> int --> long --> float --> double

byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2; // 该行报错，因为byte类型参与算术运算会自动提升为int，int赋值给byte可能损失精度

int i3 = b1 + b2; // 应该使用int接收
byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型

int num1 = 10;
double num2 = 20.0;
double num3 = num1 + num2; // 使用double接收，因为num1会自动提升为double类型

char 类型参与算术运算，使用的是计算机底层对应的十进制数值。

ASCII 码表需要我们记住三个字符对应的数值：

• ‘a’ – 97：a-z 是连续的，所以 ‘b’ 对应的数值是 98，‘c’ 是 99，依次递加
• ‘A’ – 65：A-Z 是连续的，所以 ‘B’ 对应的数值是 66，‘C’ 是 67，依次递加
• ‘0’ – 48：0-9 是连续的，所以 ‘1’ 对应的数值是 49，‘2’ 是 50，依次递加

// 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少
char ch1 = 'a';
System.out.println(ch1 + 1); // 输出98，97 + 1 = 98

char ch2 = 'A';
System.out.println(ch2 + 1); // 输出66，65 + 1 = 66

char ch3 = '0';
System.out.println(ch3 + 1); // 输出49，48 + 1 = 49

2.2 字符串的 + 操作

当 + 操作中出现字符串时，这个 + 是字符串连接符，而不是算术运算。

System.out.println("the" + 666); // 输出：the666
System.out.println("the" + true); // 输出：thetrue

当连续进行 + 操作时，从左到右逐个执行。

System.out.println(1 + 99 + "你好");            // 输出：100你好
System.out.println(1 + 2 + "the" + 3 + 4);   // 输出：3the34
// 可以使用小括号改变运算的优先级 
System.out.println(1 + 2 + "the" + (3 + 4)); // 输出：3the7

3.自增自减运算符

++ 和 -- 既可以放在变量的后边，也可以放在变量的前边。

• 单独使用的时候，++ 和 -- 无论是放在变量的前边还是后边，结果是一样的。

• 参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做 ++ 或者 --。

• 参与操作的时候，如果放在变量的前边，先拿变量做 ++ 或者 --，后拿变量参与操作。

• ++ 和 --，只能操作变量不能操作常量。

int i = 10;
i++; // 单独使用
System.out.println("i:" + i); // i:11

int j = 10;
++j; // 单独使用
System.out.println("j:" + j); // j:11

int x = 10;
int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
System.out.println("x:" + x + ", y:" + y); // x:11，y:10

int m = 10;
int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
System.out.println("m:" + m + ", m:" + m); // m:11，m:11

练习：

int x = 10;
int y = x++ + x++ + x++;
System.out.println(y); // y的值是多少？

解析：三个表达式都是 ++ 在后，所以每次使用的都是自增前的值，但程序自左至右执行，所以第一次自增时，使用的是 10 进行计算，但第二次自增时，x 的值已经自增到 11 了，所以第二次使用的是 11，然后再次自增……，所以整个式子应该是：int y = 10 + 11 + 12;
输出结果为33。

注意：通过此练习深刻理解自增和自减的规律，但实际开发中强烈建议不要写这样的代码！小心挨打！

4.赋值运算符

赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。

注意：扩展的赋值运算符隐含了强制类型转换。

short s = 10;
s = s + 10; // 此行代码报错，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度

s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);

5.关系运算符

注意：

• 关系运算符的结果都是 boolean 类型，要么是 true，要么是 false。
• 千万不要把 == 误写成 =，== 是判断是否相等的关系，= 是赋值。

int a = 10;
int b = 20;
System.out.println(a == b); // false
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); // true

// 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
boolean flag = a > b;
System.out.println(flag); // 输出false

6.逻辑运算符

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。

//定义变量
int i = 10;
int j = 20;
int k = 30;

//& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
System.out.println((i > j) & (i > k)); //false & false,输出false
System.out.println((i < j) & (i > k)); //true & false,输出false
System.out.println((i > j) & (i < k)); //false & true,输出false
System.out.println((i < j) & (i < k)); //true & true,输出true
System.out.println("--------");

//| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
System.out.println((i > j) | (i > k)); //false | false,输出false
System.out.println((i < j) | (i > k)); //true | false,输出true
System.out.println((i > j) | (i < k)); //false | true,输出true
System.out.println((i < j) | (i < k)); //true | true,输出true
System.out.println("--------");

//^ “异或”，相同为false，不同为true
System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
System.out.println("--------");

//! “非”，取反
System.out.println((i > j)); //false
System.out.println(!(i > j)); //!false，,输出true

7.短路逻辑运算符

在逻辑与运算中，只要有一个表达式的值为 false，那么结果就可以判定为 false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理，在逻辑或运算中，一旦发现值为 true，右边的表达式将不再参与运算。

• 逻辑与 &，无论左边真假，右边都要执行。
• 短路与 &&，如果左边为真，右边执行；如果左边为假，右边不执行。
• 逻辑或 |，无论左边真假，右边都要执行。
• 短路或 ||，如果左边为假，右边执行；如果左边为真，右边不执行。

int x = 3;
int y = 4;
System.out.println((x++ > 4) & (y++ > 5)); // 两个表达式都会运算
System.out.println(x); // 4
System.out.println(y); // 5

int x = 3;
int y = 4;
System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false，右边不参与运算
System.out.println(x); // 4
System.out.println(y); // 4

8.三元运算符

三元运算符语法格式：

关系表达式 ? 表达式1 : 表达式2;

解释：问号前面的位置是判断的条件，判断结果为 boolean 型，为 true 时，调用表达式1；为 false 时，调用表达式2。

其逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。

举例：

int a = 10;
int b = 20;
int c = a > b ? a : b; // 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值

9.位运算符

Java 中的所有数据都是以补码形式表示，整数默认是 int 类型，int 占 4 个字节，即 32 位。

(1) 按位与 &

运算规则：两个数都转为二进制，然后从高位开始比较，如果两位都为 1 则为 1，否则为 0。

比如：129 & 128 = 128

129 : 00000000   00000000   00000000   10000001 128 : 00000000   00000000   00000000   10000000 a n s : 00000000   00000000   00000000   10000000 129:00000000 00000000 00000000 10000001\ 128:00000000 00000000 00000000 10000000\ ans:00000000 00000000 00000000 10000000 129:00000000 00000000 00000000 10000001128:00000000 00000000 00000000 10000000ans:00000000 00000000 00000000 10000000

(2) 按位或 |

运算规则：两个数都转为二进制，然后从高位开始比较，两位只要有一个为 1 则为 1，否则为 0。

比如：129 | 128 = 129

129 : 00000000   00000000   00000000   10000001 128 : 00000000   00000000   00000000   10000000 a n s : 00000000   00000000   00000000   10000001 129:00000000 00000000 00000000 10000001\ 128:00000000 00000000 00000000 10000000\ ans:00000000 00000000 00000000 10000001 129:00000000 00000000 00000000 10000001128:00000000 00000000 00000000 10000000ans:00000000 00000000 00000000 10000001

(3) 按位异或 ^

运算规则：两个数都转为二进制，然后从高位开始比较，如果两位相同则为 0，不相同则为 1。

比如：129 ^ 128 = 1

129 : 00000000   00000000   00000000   10000001 128 : 00000000   00000000   00000000   10000000 a n s : 00000000   00000000   00000000   00000001 129:00000000 00000000 00000000 10000001\ 128:00000000 00000000 00000000 10000000\ ans:00000000 00000000 00000000 00000001 129:00000000 00000000 00000000 10000001128:00000000 00000000 00000000 10000000ans:00000000 00000000 00000000 00000001

(4) 按位非 ~

运算规则：将数转为二进制，如果位为 0 则为 1，如果位为 1 则为 0。

比如：~37 = -38

37 : 00000000   00000000   00000000   00100101 ∼   : 11111111   11111111   11111111   11011010 37:00000000 00000000 00000000 00100101\ sim :11111111 11111111 11111111 11011010\ 37:00000000 00000000 00000000 00100101∼ :11111111 11111111 11111111 11011010