# Java 运算符

> 原文： [https://www.programiz.com/java-programming/operators](https://www.programiz.com/java-programming/operators)

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

运算符是对操作数（变量和值）进行运算的特殊符号（字符）。 例如，`+`是执行加法的运算符。

在上一教程中，您将了解 [Java 变量](/java-programming/variables-primitive-data-types#variables "Java Variables")。 您将学习声明变量并为变量分配值。 现在，您将学习使用运算符来操纵变量。

* * *

## 赋值运算符

赋值运算符在 Java 中用于为变量赋值。 例如，

```java
int age;
age = 5;

```

赋值运算符将其右侧的值分配给其左侧的变量。 在此，使用=运算符将`5`分配给变量`age`。

也有其他赋值运算符。 但是，为简单起见，我们将在本文后面学习其他赋值运算符。

* * *

### 示例 1：赋值运算符

```java
class AssignmentOperator {
    public static void main(String[] args) {

        int number1, number2;

        // Assigning 5 to number1 
        number1 = 5;
        System.out.println(number1);

        // Assigning value of variable number2 to number1
        number2 = number1;
        System.out.println(number2);
    }
} 
```

**输出**：

```java
5
5 
```

## 算术运算符

算术运算符用于执行数学运算，例如加法，减法，乘法等。

| 运算符 | 含义 |
| `+` | 加法（也用于字符串连接） |
| `-` | 减法运算符 |
| `*` | 乘法运算符 |
| `/` | 除法运算符 |
| `%` | 余数运算符 |

* * *

### 示例 2：算术运算符

```java
class ArithmeticOperator {
    public static void main(String[] args) {

        double number1 = 12.5, number2 = 3.5, result;

        // Using addition operator
        result = number1 + number2;
        System.out.println("number1 + number2 = " + result);

        // Using subtraction operator
        result = number1 - number2;
        System.out.println("number1 - number2 = " + result);

        // Using multiplication operator
        result = number1 * number2;
        System.out.println("number1 * number2 = " + result);

        // Using division operator
        result = number1 / number2;
        System.out.println("number1 / number2 = " + result);

        // Using remainder operator
        result = number1 % number2;
        System.out.println("number1 % number2 = " + result);
    }
} 
```

**输出**：:

```java
number1 + number2 = 16.0
number1 - number2 = 9.0
number1 * number2 = 43.75
number1 / number2 = 3.5714285714285716
number1 % number2 = 2.0 
```

在上面的示例中，所有使用的操作数都是变量。 但是，根本没有必要。 算术运算符中使用的操作数也可以是[字面值](https://www.programiz.com/java-programming/variables-primitive-data-types#literals)。 例如，

```java
result = number1 + 5.2;
result = 2.3 + 4.5;
number2 = number1 -2.9;

```

`+`运算符还可用于连接两个或多个字符串。

* * *

### 示例 3：算术运算符添加字符串

```java
class ArithmeticOperator {
    public static void main(String[] args) {

        String start, middle, end, result;

        start = "Talk is cheap. ";
        middle = "Show me the code. ";
        end = "- Linus Torvalds";

        result = start + middle + end;
        System.out.println(result);
    }
} 
```

**输出**：:

```java
Talk is cheap. Show me the code. - Linus Torvalds 
```

## 一元运算符

一元运算符仅对一个操作数执行运算。

| Operator | Meaning |
| `+` | 一元加号（由于数字为正数而不使用它，因此无需使用） |
| `-` | 一元减：反转表达式的符号 |
| `++` | 增量运算符：将值增加 1 |
| `--` | 减量运算符：将值减 1 |
| `!` | 逻辑补码运算符：反转布尔值 |

* * *

### 示例 4：一元运算符

```java
class UnaryOperator {
    public static void main(String[] args) {

        double number = 5.2, resultNumber;
        boolean flag = false;

        System.out.println("+number = " + +number);
        // number is equal to 5.2 here.

        System.out.println("-number = " + -number);
        // number is equal to 5.2 here.

        // ++number is equivalent to number = number + 1
        System.out.println("number = " + ++number);
        // number is equal to 6.2 here.

        // -- number is equivalent to number = number - 1
        System.out.println("number = " + --number);
        // number is equal to 5.2 here.

        System.out.println("!flag = " + !flag);
        // flag is still false.
    }
} 
```

**输出**：:

```java
+number = 5.2
-number = -5.2
number = 6.2
number = 5.2
!flag = true 
```

### 增量和减量运算符

您还可以在 Java 中同时使用`++`和`--`运算符作为前缀和后缀。`++`运算符将值增加 1，`--`运算符将值减小 1。

```java
int myInt = 5;
++myInt   // myInt becomes 6
myInt++   // myInt becomes 7
--myInt   // myInt becomes 6
myInt--   // myInt becomes 5

```

到目前为止很简单。 但是，在使用递增和递减运算符作为前缀和后缀时，存在一个至关重要的区别。 考虑这个例子，

### 示例 5：一元运算符

```java
class UnaryOperator {
    public static void main(String[] args) {

        double number = 5.2;

        System.out.println(number++);
        System.out.println(number);

        System.out.println(++number);
        System.out.println(number);
    }
} 
```

**输出**：:

```java
5.2
6.2
7.2
7.2 
```

在这里，请注意这行，

```java
System.out.println(number++); 
```

执行此语句时，将首先求值原始值。 然后，`number`增加。 这就是获得`5.2`作为输出的原因。

现在，当线，

```java
System.out.println(number); 
```

将打印增加的值。 那就是`6.2`。

但是，

```java
System.out.println(++number); 
```

首先将`number`增加`1`，然后执行该语句。 因此，输出为`7.2`。

减量`--`运算符的情况与此类似。

* * *

## 相等和关系运算符

等式和关系运算符确定两个操作数之间的关系。 它检查操作数是否大于，小于，等于，不等于等。 根据关系，将其求值为`true`或`false`。

| Operator | 描述 | 例 |
| `==` | 等于 | `5 == 3`求值为`false` |
| `!=` | 不等于 | `5 != 3`被求值为`true` |
| `>` | 大于 | `5 > 3`被求值为`true` |
| `<` | 小于 | `5 < 3`被求值为`false` |
| `>=` | 大于或等于 | `5 >= 5`求值为`true` |
| `<=` | 小于或等于 | `5 <= 5`求值为`true` |

相等和关系运算符用于决策和循环（稍后将进行讨论）。 现在，检查这个简单的例子。

* * *

### 示例 6：相等和关系运算符

```java
class RelationalOperator {
    public static void main(String[] args) {

        int number1 = 5, number2 = 6;

        if (number1 > number2) {
            System.out.println("number1 is greater than number2.");
        }
        else {
            System.out.println("number2 is greater than number1.");
        }
    }
} 
```

**输出**：:

```java
number2 is greater than number1. 
```

在这里，我们使用`>`运算符检查`number1`是否大于`number2`。

由于`number2`大于`number1`，因此将表达式`number1 > number2`求值为`false`。

因此，将执行`else`内部的代码块，并跳过`if`内部的代码块。

如果您不理解上面的代码，请不要担心。 您将在 [Java 中详细学习它](/java-programming/if-else-statement "Java if...else")。

现在，请记住，相等和关系运算符会比较两个操作数，并被求值为`true`或`false`。

* * *

## 运算符实例

除了关系运算符外，还有一个类型比较运算符`instanceof`，用于将对象与指定的类型进行比较。 例如，

### 示例 7：`instanceof`运算符

这是`instanceof`运算符的示例。

```java
class instanceofOperator {
    public static void main(String[] args) {

        String test = "asdf";
        boolean result;

        result = test instanceof String;
        System.out.println("Is test an object of String? " + result);
    }
} 
```

**输出**：:

```java
Is test an object of String? true 
```

这里，由于变量`test`是`String`类型的。 因此，`instanceof`运算符返回`true`。 要了解更多信息，请访问 [Java 实例](/java-programming/instanceof "Java instanceof")。

* * *

## 逻辑运算符

逻辑运算符`||`（条件或）和`&&`（条件与）对布尔表达式进行运算。 它们是这样工作的。

| Operator | Description | Example |
| `&#124;&#124;` | 条件或：`true`，如果布尔表达式中的任何一个为`true` | 将`false &#124;&#124; true`求值为`true` |
| `&&` | 条件与：如果所有布尔表达式均为`true`，则为`true` | 将`false && true`求值为`false` |

* * *

### 示例 8：逻辑运算符

```java
class LogicalOperator {
    public static void main(String[] args) {

        int number1 = 1, number2 = 2, number3 = 9;
        boolean result;

        // At least one expression needs to be true for the result to be true
        result = (number1 > number2) || (number3 > number1);

        // result will be true because (number1 > number2) is true
        System.out.println(result);

        // All expression must be true from result to be true	
        result = (number1 > number2) && (number3 > number1);

        // result will be false because (number3 > number1) is false
        System.out.println(result);
    }
} 
```

**输出**：:

```java
true
false 
```

**注**：逻辑运算符用于决策和循环。

* * *

## 三元运算符

条件运算符或三元运算符`?:`是`if-else`语句的简写。 条件运算符的语法为：

```java
variable = Expression ? expression1 : expression2

```

运作方式如下。

*   如果`Expression`为`true`，则将`expression1`分配给`variable`。
*   如果`Expression`为`false`，则将`expression2`分配给`variable`。

* * *

### 示例 9：三元运算符

```java
class ConditionalOperator {
    public static void main(String[] args) {

        int februaryDays = 29;
        String result;

         result =  (februaryDays == 28) ? "Not a leap year" : "Leap year";
         System.out.println(result);
    }
} 
```

**输出**：:

```java
Leap year 
```

在这里，我们使用三元运算符检查年份是否为是闰年。 要了解更多信息，请访问 [Java 三元运算符](/java-programming/ternary-operator "Java ternary operator")。

* * *

## 按位和移位运算符

为了在 Java 中执行按位和移位运算符，将使用这些运算符。

| Operator | Description |
| `~` | 按位补码 |
| `<<` | 左移 |
| `>>` | 右移 |
| `>>>` | 无符号右移 |
| `&` | 按位与 |
| `^` | 按位异或 |
| `&#124;` | 按位或 |

这些运算符不常用。 要了解更多信息，请访问 [Java 按位运算符和位移位运算符](/java-programming/bitwise-operators "Java bitwise and bit shift operators")。

* * *

### 更多分配运算符

在本文开头，我们仅讨论了一个赋值运算符`=`。 除了该运算符外，还有很多赋值运算符使我们编写更简洁的代码。

| Operator | Example | 相当于 |
| `+=` | `x += 5` | `x = x + 5` |
| `-=` | `x -= 5` | `x = x - 5` |
| `*=` | `x *= 5` | `x = x * 5` |
| `/=` | `x /= 5` | `x = x / 5` |
| `%=` | `x %= 5` | `x = x % 5` |
| `<<=` | `x <<= 5` | `x = x << 5` |
| `>>=` | `x >>= 5` | `x = x >> 5` |
| `&=` | `x &= 5` | `x = x & 5` |
| `^=` | `x ^= 5` | `x = x ^ 5` |
| `&#124;=` | `x &#124;= 5` | `x = x &#124; 5` |

现在您已经了解了 Java 运算符，是时候了解两个运算符共享一个公共操作数时表达式中的运算符的求值顺序了。 要了解这一点，请访问 [Java 运算符优先级](/java-programming/operator-precedence "Java Operator Precedence")。