【Java】基础编程之运算符的使用

一、前言

本文将介绍Java中常用的运算符，我们使用这些运算符用于实现数学运算、条件判断、位操作等多种功能。了解这些运算符的用法和特性有助于编写高效的Java代码。

二、内容

2.1 算术运算符

在Java中，算术运算符用于执行基本的数学运算。以下是常见的算术运算符：

• +：加法运算，用于将两个数相加。
• -：减法运算，用于将右边的数从左边的数中减去。
• *：乘法运算，用于将两个数相乘。
• /：除法运算，用于将左边的数除以右边的数，得到商。
• %：取余运算，用于取左边的数除以右边的数的余数。

代码示例：

// 除号：/
int num1 = 12;
int num2 = 5;
int result1 = num1 / num2;
System.out.println(result1); // Output: 2

// %: 取余运算
// 结果的符号与被模数的符号相同
// 经常使用%来判断能否被除尽的情况。
int m1 = 12;
int n1 = 5;
System.out.println("m1 % n1 = " + m1 % n1); // Output: m1 % n1 = 2

int m2 = -12;
int n2 = 5;
System.out.println("m2 % n2 = " + m2 % n2); // Output: m2 % n2 = -2

int m3 = 12;
int n3 = -5;
System.out.println("m3 % n3 = " + m3 % n3); // Output: m3 % n3 = 2

int m4 = -12;
int n4 = -5;
System.out.println("m4 % n4 = " + m4 % n4); // Output: m4 % n4 = -2

//(前)++ : 先自增1，后运算
//(后)++ : 先运算，后自增1
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1 + ", b1 = " + b1); // Output: a1 = 11, b1 = 11

int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2 + ", b2 = " + b2); // Output: a2 = 11, b2 = 10

//(前)-- : 先自减1，后运算
//(后)-- : 先运算，后自减1
int a4 = 10;
int b4 = a4--; // int b4 = --a4;
System.out.println("a4 = " + a4 + ", b4 = " + b4); // Output: a4 = 9, b4 = 10

特别说明：

1. ++a：先自增1，后运算
2. a++：先运算，后自增1
3. --a：先自减1，后运算
4. a--：先运算，后自减1
5. 连接符+：该运算符还可以在String与其他数据类型变量之间使用，用于将两个值连接成一个新的字符串。

以上是关于算术运算符的基本介绍和典型代码示例。在实际编程中，我们会经常用到这些运算符来进行基本的数学运算和字符串连接操作。记得要注意自增、自减运算的前后位置以及连接符+的使用情况。

2.2 赋值运算符

在Java中，赋值运算符用于给变量赋值。以下是常见的赋值运算符：

• =：将右边的值赋给左边的变量。
• +=：将右边的值加到左边的变量，并将结果赋给左边的变量。
• -=：将右边的值从左边的变量中减去，并将结果赋给左边的变量。
• *=：将右边的值与左边的变量相乘，并将结果赋给左边的变量。
• /=：将左边的变量除以右边的值，并将结果赋给左边的变量。
• %=：将左边的变量除以右边的值，取余并将结果赋给左边的变量。

代码示例：

int i2, j2;
// 连续赋值
i2 = j2 = 10; // i2和j2都被赋值为10

int i3 = 10, j3 = 20; // 同时声明多个变量并赋值

int num1 = 10;
num1 += 2; // 等价于 num1 = num1 + 2;
System.out.println(num1); // Output: 12

int num2 = 12;
num2 %= 5; // 等价于 num2 = num2 % 5;
System.out.println(num2); // Output: 2

short s1 = 10;
s1 += 2; // 等价于 s1 = (short)(s1 + 2); 注意：结果不会改变变量本身的数据类型
System.out.println(s1); // Output: 12

特别说明：

1. 运算的结果不会改变变量本身的数据类型。在使用复合赋值运算符时，需要注意结果可能会超出原变量数据类型的范围，导致数据截断，需要进行类型转换。
2. 在实际开发中，如果希望变量实现加2的操作，有几种方法？
   • 方式一：num = num + 2;
   • 方式二：num += 2; （推荐）
3. 如果希望变量实现加1的操作，有几种方法？
   • 方式一：num = num + 1;
   • 方式二：num += 1;
   • 方式三：num++; （推荐）

使用赋值运算符可以简化代码，并提高代码的可读性。建议在适当的情况下使用复合赋值运算符来进行简单的数学运算。

2.3 比较运算符

在Java中，比较运算符用于比较两个值的大小或判断两个引用类型变量是否指向同一个对象。以下是常见的比较运算符：

• ==：判断两个值是否相等，如果相等返回true，否则返回false。
• !=：判断两个值是否不相等，如果不相等返回true，否则返回false。
• >：判断左边的值是否大于右边的值，如果是返回true，否则返回false。
• <：判断左边的值是否小于右边的值，如果是返回true，否则返回false。
• >=：判断左边的值是否大于等于右边的值，如果是返回true，否则返回false。
• <=：判断左边的值是否小于等于右边的值，如果是返回true，否则返回false。
• instanceof：用于判断一个对象是否属于某个类或其子类的实例。如果是返回true，否则返回false。

代码示例：

int i = 10;
int j = 20;

System.out.println(i == j); // Output: false，10不等于20
System.out.println(i = j); // Output: 20，此处是赋值操作，并且返回右边的值

boolean b1 = true;
boolean b2 = false;
System.out.println(b2 == b1); // Output: false，false不等于true
System.out.println(b2 = b1); // Output: true，此处是赋值操作，并且返回右边的值

特别说明：

1. 比较运算符的结果是boolean类型，即true或false。
2. >、<、>=、<=：只能在数值类型的数据之间进行比较。
3. == 和 !=：不仅可以在数值类型数据之间进行比较，还可以在其他引用类型变量之间进行比较。例如，比较两个引用类型变量是否指向同一个对象。

比如：

Account acct1 = new Account(1000);
Account acct2 = new Account(1000);
boolean b1 = (acct1 == acct2); // 比较两个Account是否是同一个账户。
boolean b2 = (acct1 != acct2); // 判断两个Account是否不是同一个账户。

在这个例子中，我们创建了两个 Account 对象 acct1 和 acct2，它们具有相同的初始余额，但它们是不同的对象。虽然它们的初始余额相同，但它们在内存中占据不同的位置，因此 acct1 == acct2 会返回 false，而 acct1 != acct2 则会返回 true。这是因为它们是两个独立的对象实例，即使它们的内容相同。

比较运算符非常有用，我们可以用它来进行条件判断，控制程序的流程。在比较引用类型变量时，要特别注意是否需要比较它们指向的是同一个对象。

2.4 逻辑运算符

在Java中，逻辑运算符用于处理boolean类型的变量，并返回boolean类型的结果。以下是常见的逻辑运算符：

• &：逻辑与运算符，当两个条件都为true时，返回true，否则返回false。
• &&：短路逻辑与运算符，当左边的条件为false时，不再执行右边的条件，直接返回false。
• |：逻辑或运算符，当两个条件有一个为true时，返回true，否则返回false。
• ||：短路逻辑或运算符，当左边的条件为true时，不再执行右边的条件，直接返回true。
• !：逻辑非运算符，用于取反，如果条件为true，返回false，如果条件为false，返回true。
• ^：逻辑异或运算符，当两个条件不同时返回true，否则返回false。

代码示例：

// 示例数据
int x = 10;
int y = 5;

// 逻辑与运算符 (&)
boolean resultAnd = (x > 7) & (y < 3);
System.out.println("逻辑与运算结果：" + resultAnd); // 输出：false

// 短路逻辑与运算符 (&&)
boolean resultShortAnd = (x > 7) && (y < 3);
System.out.println("短路逻辑与运算结果：" + resultShortAnd); // 输出：false

// 逻辑或运算符 (|)
boolean resultOr = (x > 12) | (y < 7);
System.out.println("逻辑或运算结果：" + resultOr); // 输出：true

// 短路逻辑或运算符 (||)
boolean resultShortOr = (x > 12) || (y < 7);
System.out.println("短路逻辑或运算结果：" + resultShortOr); // 输出：true

// 逻辑非运算符 (!)
boolean resultNotX = !(x > 7);
boolean resultNotY = !(y < 3);
System.out.println("逻辑非运算结果 X：" + resultNotX); // 输出：false
System.out.println("逻辑非运算结果 Y：" + resultNotY); // 输出：true

// 逻辑异或运算符 (^)
boolean resultXor1 = (x > 7) ^ (y < 3);
boolean resultXor2 = (x > 7) ^ (y < 7);
System.out.println("逻辑异或运算结果 1：" + resultXor1); // 输出：true
System.out.println("逻辑异或运算结果 2：" + resultXor2); // 输出：false

特别说明：

1. 逻辑运算符操作的都是boolean类型的变量，并返回boolean类型的结果。
2. && 和 || 是短路逻辑运算符，当左边的条件满足时，不再执行右边的条件，直接返回结果。这是因为逻辑与运算在遇到false时，无论右边条件是否为true，结果都是false；逻辑或运算在遇到true时，无论右边条件是否为false，结果都是true，因此不需要再执行右边的条件。

逻辑运算符非常常用，可以用于条件判断、循环控制等场景，可以帮助我们写出更加灵活和高效的代码。

2.5 位运算符

在Java中，位运算符用于对整数类型的数据进行位操作。以下是常见的位运算符：

• <<：左移位运算符，在一定范围内，每向左移1位，相当于乘以2的幂。
• >>：带符号右移位运算符，在一定范围内，每向右移1位，相当于除以2的幂，符号位不变。
• >>>：无符号右移位运算符，在一定范围内，每向右移1位，相当于无符号右移，高位补0。
• &：按位与运算符，对两个整数进行二进制位与操作。
• |：按位或运算符，对两个整数进行二进制位或操作。
• ^：按位异或运算符，对两个整数进行二进制位异或操作。
• ~：按位取反运算符，对整数进行二进制位取反操作。

代码举例：

// 位运算符示例
int a = 5; // 二进制：0000 0101
int b = 3; // 二进制：0000 0011

// 左移位运算符 (<<)
int leftShiftResult = a << 2; // 将'a'的二进制向左移动两位
// 二进制：0001 0100
System.out.println("左移位运算结果: " + leftShiftResult); // 输出：20

// 带符号右移位运算符 (>>)
int rightShiftResult = a >> 1; // 将'a'的二进制向右移动一位
// 二进制：0000 0010
System.out.println("带符号右移位运算结果: " + rightShiftResult); // 输出：2

// 无符号右移位运算符 (>>>)
int unsignedRightShiftResult = a >>> 1; // 将'a'的二进制向右移动一位（无符号）
// 二进制：0000 0010
System.out.println("无符号右移位运算结果: " + unsignedRightShiftResult); // 输出：2

// 按位与运算符 (&)
int bitwiseANDResult = a & b; // 对'a'和'b'进行按位与操作
// 二进制：0000 0001
System.out.println("按位与运算结果: " + bitwiseANDResult); // 输出：1

// 按位或运算符 (|)
int bitwiseORResult = a | b; // 对'a'和'b'进行按位或操作
// 二进制：0000 0111
System.out.println("按位或运算结果: " + bitwiseORResult); // 输出：7

// 按位异或运算符 (^)
int bitwiseXORResult = a ^ b; // 对'a'和'b'进行按位异或操作
// 二进制：0000 0110
System.out.println("按位异或运算结果: " + bitwiseXORResult); // 输出：6

// 按位取反运算符 (~)
int bitwiseNOTResult = ~a; // 对'a'进行按位取反操作
// 二进制：1111 1010
System.out.println("按位取反运算结果: " + bitwiseNOTResult); // 输出：-6

特别说明：

1. 位运算符操作的都是整型的数据。
2. <<：在一定范围内，每向左移1位，相当于乘以2的幂。
3. >>：带符号右移位运算符，在一定范围内，每向右移1位，相当于除以2的幂，符号位不变。
4. >>>：无符号右移位运算符，在一定范围内，每向右移1位，相当于无符号右移，高位补0。

在实际开发中，位运算符通常用于一些特定的位操作，例如优化算法，处理二进制数据等。务必谨慎使用位运算符，确保理解运算符的功能和效果。

2.6 三元运算符

在Java中，三元运算符是一种简化条件判断的运算符，格式为：

• (条件表达式) ? 表达式1 : 表达式2。

它可以根据条件表达式的结果来选择执行表达式1或表达式2。

代码示例：

int a = 10;
int b = 20;
int max = (a > b) ? a : b;
System.out.println("较大值为：" + max); // Output: 较大值为：20

特别说明：

1. 条件表达式的结果必须是boolean类型，即true或false。
2. 根据条件表达式的真或假，决定执行表达式1还是表达式2。如果条件表达式为true，则执行表达式1；如果条件表达式为false，则执行表达式2。
3. 表达式1和表达式2的结果类型要求一致，例如都是整数类型、浮点类型或其他类型。
4. 三元运算符可以嵌套使用，即在表达式1或表达式2中再次使用三元运算符。

凡是可以使用三元运算符的地方，都可以改写为if-else结构，反之不成立。然而，如果程序既可以使用三元运算符，又可以使用if-else结构，建议优先选择三元运算符。原因是三元运算符更为简洁，执行效率也较高。但在实际编程中，也要注意代码的可读性和维护性，适当选择if-else结构可能更易于理解。

三、总结

本文详细介绍了Java中常见的运算符，我们学习了它们的用法、示例代码以及注意事项。这些运算符是Java编程的基础，掌握它们对于进行各种数学计算、条件判断和位操作非常重要。在实际开发中，根据不同的情况选择适当的运算符来提高代码的效率和可读性。