Java 运算符

在本教程中，您将通过示例了解 Java 中不同类型的运算符、它们的语法以及如何使用它们。

在本教程中，您将通过示例了解 Java 中不同类型的运算符、它们的语法以及如何使用它们。

运算符是对变量和值执行操作的符号。例如， + 是用于加法的运算符，* 是用于乘法的运算符。

Java 中的运算符可以分为 5 种类型：

  1. 算术运算符
  2. 赋值运算符
  3. 比较运算符
  4. 逻辑运算符
  5. 一元运算符
  6. 按位运算符

Java 算术运算符

算术运算符用于对变量和数据执行算术运算。例如，

a + b;

这里， + 运算符用于将两个变量相加。 同样，Java 中还有各种其他算术运算符。

运算符 说明
+ 加法
- 减法
* 乘法
/ 触发
% 求模运算（除法后的余数）

示例 1：算术运算符

public class Main {
  public static void main(String[] args) {

    // 声明变量
    int a = 12, b = 5;

    // 加法
    System.out.println("a + b = " + (a + b));

    // 减法
    System.out.println("a - b = " + (a - b));

    // 乘法
    System.out.println("a * b = " + (a * b));

    // 除法
    System.out.println("a / b = " + (a / b));

    // 求模
    System.out.println("a % b = " + (a % b));
  }
}

输出

a + b = 17
a - b = 7
a * b = 60
a / b = 2
a % b = 2

除法运算符

请注意我们的程序中的 a / b，该 / 运算符是除法运算符。

如果我们对两个整数使用除法运算符，那么结果商也将是一个整数。并且，如果其中一个操作数是浮点数，我们将得到的结果也将是浮点数。

In Java,

(9 / 2) is 4
(9.0 / 2) is 4.5
(9 / 2.0) is 4.5
(9.0 / 2.0) is 4.5

求模运算符

求模运算符 % 计算余数。a = 7 除以 b = 4 的余数是 3 。

Java 赋值运算符

Java 中使用赋值运算符 = 为变量赋值。例如，

int age;
age = 5;

这里， = 是赋值运算符。它将其右侧的值分配给其左侧的变量。

让我们看看 Java 中更多可用的赋值运算符。

赋值运算符 例子 相当于
= a = b; a = b;
+= a += b; a = a + b;
-= a -= b; a = a - b;
*= a *= b; a = a * b;
/= a /= b; a = a / b;
%= a %= b; a = a % b;

示例 2：赋值运算符

public class Main {
  public static void main(String[] args) {

    // 声明变量
    int a = 4;
    int var;

    // 赋值
    var = a;
    System.out.println("var using =: " + var);

    // 使用 =+ 赋值
    var += a;
    System.out.println("var using +=: " + var);

    // 使用 =* 赋值
    var *= a;
    System.out.println("var using *=: " + var);
  }
}

输出

var using =: 4
var using +=: 8
var using *=: 32

Java 比较运算符

比较运算符用于检查两个操作数之间的关系。例如，

// 检查 a 是否小于 b
a < b;

这里， < 运算符是比较运算符。它检查左边的操作数 是否小于 右边的操作数。

它返回 true 或 false 。

比较运算符 说明 例子
== 等于 3 == 5 返回 false
!= 不等于 3 != 5 返回 true
> 大于 3 > 5 返回 false
< 小于 3 < 5 返回 true
>= 大于或等于 3 >= 5 返回 false
<= 小于或等于 3 <= 5 返回 true

示例 3：比较运算符

public class Main {
  public static void main(String[] args) {

    // 声明变量
    int a = 7, b = 11;

    // 输出 a 和 b
    System.out.println("a is " + a + " and b is " + b);

    // ==
    System.out.println(a == b);  // false

    // !=
    System.out.println(a != b);  // true

    // >
    System.out.println(a > b);  // false

    // <
    System.out.println(a < b);  // true

    // >=
    System.out.println(a >= b);  // false

    // <=
    System.out.println(a <= b);  // true
  }
}

注意：比较运算符用于决策和循环。

Java 逻辑运算符

逻辑运算符用于检查表达式是否为 true 或 false ，它们用于决策。

赋值运算符 例子 意义
&& （逻辑与） expression1 && expression2 两个表达式都是 true 结果才是 true
|| （逻辑或） expression1 || expression2 两个表达式只要又一个是 true 结果就是 true
! （逻辑非） !expression 如果表达式是 true 结果是 false ，反之亦然

示例 4：逻辑运算符

public class Main {
  public static void main(String[] args) {

    // &&
    System.out.println((5 > 3) && (8 > 5));  // true
    System.out.println((5 > 3) && (8 < 5));  // false

    // ||
    System.out.println((5 < 3) || (8 > 5));  // true
    System.out.println((5 > 3) || (8 < 5));  // true
    System.out.println((5 < 3) || (8 < 5));  // false

    // !
    System.out.println(!(5 == 3));  // true
    System.out.println(!(5 > 3));  // false
  }
}

程序结果说明

  • (5 > 3) && (8 > 5) 返回 true ，因为 (5 > 3) 和 (8 > 5) 都是 true 。
  • (5 > 3) && (8 < 5) 返回 false ， 因为 (8 < 5) 是 false 。
  • (5 < 3) || (8 > 5) 返回 true ， 因为 (8 > 5) 是 true 。
  • (5 > 3) && (8 > 5) 返回 true ， 因为 (5 > 3) 是 true 。
  • (5 > 3) && (8 > 5) 返回 false ，因为 (5 < 3) 和 (8 < 5) 都是 false 。
  • !(5 == 3) 返回 true 因为 5 == 3 是 false 。
  • !(5 > 3) 返回 false 因为 5 > 3 是 true 。

Java 一元运算符

一元运算符仅用于一个操作数。下表是 Java 中的所有的一元运算符：

操作员 意义
+ 正数，一般省略不写
- 负数
++ 自增，将值增加 1
-- 自减，将值减小 1
! 逻辑非，反转布尔值

自增和自减运算符

Java 还分别提供了自增和自减运算符： ++ 和 -- 。 ++ 将操作数的值增加 1， -- 将其减少 1。例如，

int num = 5;

// 自增
++num;

这里的值 数量从其初始值 5 增加到 6。

示例 5：自增和自减运算符

public class Main {
  public static void main(String[] args) {

    // 声明变量
    int a = 12, b = 12;
    int result1, result2;

    // 原始值
    System.out.println("Value of a: " + a);

    // 自增
    result1 = ++a;
    System.out.println("After increment: " + result1);

    System.out.println("Value of b: " + b);

    // 自减
    result2 = --b;
    System.out.println("After decrement: " + result2);
  }
}

输出

Value of a: 12
After increment: 13
Value of b: 12
After decrement: 11

在上面的程序中，我们使用了 ++ 和 -- 运算符作为前缀 (++a, --b)。我们也可以将这些运算符用作后缀 (a++, b++)。

Java 位运算符

Java 中的按位运算符用于对操作数执行位运算操作。例如：

对 35 按位取反

35 = 00100011 (二进制)

~ 00100011
  ________
  11011100  = 220 (十进制)

这里， ~ 是一个按位运算符。它反转每个位的值（0 到 1 和 1 到 0）。

Java 中存在的各种按位运算符是：

运算符 说明
~ 按位取反
<< 左移
>> 右移
>>> 无符号右移
& 按位与
^ 按位异或

这些运算符在 Java 中通常不使用。若现在要了解更多信息，请访问 Java 按位运算符。

其他运算符

除了这些运算符之外，Java 中还有其他附加运算符。

Java 实例运算符

instanceof 运算符检查对象是否是一个特定类的实例。例如，

public class Main {
  public static void main(String[] args) {

    String str = "GoBeta";
    boolean result;

    // checks if str is an instance of
    // the String class
    result = str instanceof String;
    System.out.println("str 是 String 类的实例吗？ " + result);
  }
}

输出

str 是 String 类的实例吗？ true

本例中， 字符串是 String 类的一个实例。因此， instanceof 运算符返回 true 。要了解更多信息，请访问 Java instanceof。

Java 三元运算符

三元运算符（条件运算符）是 if-then-else 语句的简写。例如，

variable = Expression ? expression1 : expression2

工作原理：

  • 如果 Expression 是 true ， 则将 expression1 分配给 variable
  • 如果 Expression 是 false ， 则将 expression2 分配给 variable

让我们看一个三元运算符的例子。

public class Java {
  public static void main(String[] args) {

    int februaryDays = 29;
    String result;

    // 三元运算符
    result = (februaryDays == 28) ? "平年" : "闰年";
    System.out.println(result);
  }
}

输出

闰年

在上面的例子中，我们使用了三元运算符来检查年份是否是闰年。要了解更多信息，请访问 Java 三元运算符章节。

现在您了解了 Java 运算符，是时候了解运算符的计算顺序了。要了解更多信息，请访问 Java 运算符优先级章节。

Java 原始数据类型 Java 输入和输出