# Java 表达式

原文：http://zetcode.com/lang/java/expressions/

在 Java 教程的这一部分中，我们将讨论表达式。

表达式是根据操作数和运算符构造的。 表达式的运算符指示将哪些运算应用于操作数。 表达式中运算符的求值顺序由运算符的优先级和关联性确定。

运算符是特殊符号，表示已执行某个过程。 编程语言的运算符来自数学。 程序员处理数据。 运算符用于处理数据。 操作数是运算符的输入（参数）之一。

一个运算符通常有一个或两个操作数。 那些仅使用一个操作数的运算符称为一元运算符。 那些使用两个操作数的对象称为二进制运算符。 还有一个三元运算符`?:`可与三个操作数一起使用。

某些运算符可以在不同的上下文中使用。 例如`+`运算符。 它可以在不同情况下使用。 它添加数字，连接字符串或指示数字的符号。 我们说运算符是重载。

## Java 符号运算符

有两个符号运算符：`+`和`-`。 它们用于指示或更改值的符号。

`com/zetcode/SignOperators.java`

```java
package com.zetcode;

public class SignOperators {

    public static void main(String[] args) {

        System.out.println(2);
        System.out.println(+2);
        System.out.println(-2);
    }
}

```

`+`和`-`符号指示值的符号。 加号可用于表示我们有一个正数。 可以将其省略，并且通常可以这样做。

`com/zetcode/MinusSign.java`

```java
package com.zetcode;

public class MinusSign {

    public static void main(String[] args) {

        int a = 1;

        System.out.println(-a);
        System.out.println(-(-a));
    }
}

```

减号更改值的符号。

## Java 赋值运算符

赋值运算符`=`将值赋给变量。 变量是值的占位符。 在数学中，=运算符具有不同的含义。 在等式中，`=`运算符是一个相等运算符。 等式的左侧等于右侧。

```java
int x = 1;

```

在这里，我们为`x`变量分配一个数字。

```java
x = x + 1;

```

这个表达式在数学上没有意义，但是在编程中是合法的。 表达式将 1 加到`x`变量。 右侧等于 2，并且 2 分配给`x`。

```java
3 = x;

```

此代码行导致语法错误。 我们无法为文字分配值。

## Java 连接字符串

在 Java 中，`+`运算符还用于连接字符串。

`com/zetcode/ConcatenateStrings.java`

```java
package com.zetcode;

public class ConcatenateStrings {

    public static void main(String[] args) {

        System.out.println("Return " + "of " + "the king.");
        System.out.println("Return".concat(" of").concat(" the king."));
    }
}

```

我们将三个字符串连接在一起。

```java
System.out.println("Return " + "of " + "the king.");

```

字符串用`+`运算符连接。

```java
System.out.println("Return".concat(" of").concat(" the king."));

```

连接字符串的另一种方法是`concat()`方法。

```java
$ java ConcatenateStrings.java
Return of the king.
Return of the king.

```

这是程序的输出。

## Java 自增和自减运算符

将值递增或递减一个是编程中的常见任务。 Java 为此有两个方便的运算符：`++`和`--`。

```java
x++;
x = x + 1;
...
y--;
y = y - 1;

```

上面两对表达式的作用相同。

`com/zetcode/IncDec.java`

```java
package com.zetcode;

public class IncDec {

    public static void main(String[] args) {

        int x = 6;

        x++;
        x++;

        System.out.println(x);

        x--;
        System.out.println(x);
    }
}

```

在上面的示例中，我们演示了两个运算符的用法。

```java
int x = 6;

x++;
x++;

```

将`x`变量初始化为 6。然后将`x`递增两次。 现在变量等于 8。

```java
x--;

```

我们使用减量运算符。 现在变量等于 7。

```java
$ java IncDec.java
8
7

```

这是示例的输出。

## Java 算术运算符

下表是 Java 中的算术运算符表。

| 符号 | 名称 |
| --- | --- |
| `+` | 加法 |
| `-` | 减法 |
| `*` | 乘法 |
| `/` | 除法 |
| `%` | 余数 |

以下示例显示了算术运算。

`com/zetcode/Arithmetic.java`

```java
package com.zetcode;

public class Arithmetic {

    public static void main(String[] args) {

        int a = 10;
        int b = 11;
        int c = 12;

        int add = a + b + c;
        int sb = c - a;
        int mult = a * b;
        int div = c / 3;
        int rem = c % a;

        System.out.println(add);
        System.out.println(sb);
        System.out.println(mult);
        System.out.println(div);
        System.out.println(rem);
    }
}

```

在前面的示例中，我们使用加法，减法，乘法，除法和余数运算。 这些都是数学所熟悉的。

```java
int rem = c % a;

```

`%`运算符称为余数或模运算符。 它找到一个数除以另一个的余数。 例如`9 % 4`，9 模 4 为 1，因为 4 两次进入 9 且余数为 1。

```java
$ java Arithmetic.java
33
2
110
4
2

```

这是示例的输出。

接下来，我们将说明整数除法和浮点除法之间的区别。

`com/zetcode/Division.java`

```java
package com.zetcode;

public class Division {

    public static void main(String[] args) {

        int c = 5 / 2;
        System.out.println(c);

        double d = 5 / 2.0;
        System.out.println(d);
    }
}

```

在前面的示例中，我们将两个数字相除。

```java
int c = 5 / 2;

```

在这段代码中，我们完成了整数除法。 除法运算的返回值为整数。 当我们将两个整数相除时，结果是一个整数。

```java
double d = 5 / 2.0;

```

如果值之一是`double`或`float`，则执行浮点除法。 在我们的例子中，第二个操作数是双精度数，因此结果是双精度数。

```java
$ java Division.java
2
2.5

```

我们看到了程序的结果。

## Java 布尔运算符

在 Java 中，我们有三个逻辑运算符。 `boolean`关键字用于声明布尔值。

| 符号 | 名称 |
| --- | --- |
| `&&` | 逻辑与 |
| <code>&#124;&#124;</code> | 逻辑或 |
| `!` | 否定 |

布尔运算符也称为逻辑运算符。

`com/zetcode/BooleanOperators.java`

```java
package com.zetcode;

public class BooleanOperators {

    public static void main(String[] args) {

        int x = 3;
        int y = 8;

        System.out.println(x == y);
        System.out.println(y > x);

        if (y > x) {

            System.out.println("y is greater than x");
        }
    }
}

```

许多表达式导致布尔值。 例如，在条件语句中使用布尔值。

```java
System.out.println(x == y);
System.out.println(y > x);

```

关系运算符始终导致布尔值。 这两行分别显示`false`和`true`。

```java
if (y > x) {

    System.out.println("y is greater than x");
}

```

仅在满足括号内的条件时才执行`if`语句的主体。 `y > x`返回`true`，因此消息“`y`大于`x`”被打印到终端。

`true`和`false`关键字表示 Java 中的布尔文字。

`com/zetcode/AndOperator.java`

```java
package com.zetcode;

public class AndOperator {

    public static void main(String[] args) {

        boolean a = true && true;
        boolean b = true && false;
        boolean c = false && true;
        boolean d = false && false;

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}

```

该代码示例显示了逻辑和（`&&`）运算符。 仅当两个操作数均为`true`时，它的求值结果为`true`。

```java
$ java AndOperator.java
true
false
false
false

```

`true`只产生一个表达式。

如果两个操作数中的任何一个为真，则逻辑或（`||`）运算符求值为`true`。

`com/zetcode/OrOperator.java`

```java
package com.zetcode;

public class OrOperator {

    public static void main(String[] args) {

        boolean a = true || true;
        boolean b = true || false;
        boolean c = false || true;
        boolean d = false || false;

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}

```

如果运算符的任一侧为真，则操作的结果为真。

```java
$ java OrOperator.java
true
true
true
false

```

四个表达式中的三个导致`true`。

否定运算符`!`将`true`设为`false`，并将`false`设为`false`。

`com/zetcode/Negation.java`

```java
package com.zetcode;

public class Negation {

    public static void main(String[] args) {

        System.out.println(! true);
        System.out.println(! false);
        System.out.println(! (4 < 3));
    }
}

```

该示例显示了否定运算符的作用。

```java
$ java Negation.java
false
true
true

```

This is the output of the program.

`||`和`&&`运算符经过短路求值。 短路求值意味着仅当第一个参数不足以确定表达式的值时才求值第二个参数：当逻辑的第一个参数为`false`时，总值必须为`false`; 当逻辑或的第一个参数为`true`时，总值必须为`true`。 短路求值主要用于提高性能。

一个例子可以使这一点更加清楚。

`com/zetcode/ShortCircuit.java`

```java
package com.zetcode;

public class ShortCircuit {

    public static boolean One() {

        System.out.println("Inside one");
        return false;
    }

    public static boolean Two() {

        System.out.println("Inside two");
        return true;
    }

    public static void main(String[] args) {

        System.out.println("Short circuit");

        if (One() && Two()) {

            System.out.println("Pass");
        }

        System.out.println("#############");

        if (Two() || One()) {

            System.out.println("Pass");
        }
    }
}

```

在示例中，我们有两种方法。 它们在布尔表达式中用作操作数。 我们将看看它们是否被调用。

```java
if (One() && Two()) {

    System.out.println("Pass");
}

```

`One()`方法返回`false`。 短路`&&`不求值第二种方法。 没有必要。 一旦操作数为假，逻辑结论的结果始终为假。 仅将“`Inside one`”打印到控制台。

```java
if (Two() || One()) {

    System.out.println("Pass");
}

```

在第二种情况下，我们使用`||`运算符，并使用`Two()`方法作为第一个操作数。 在这种情况下，“`Inside two`”和“`Pass`”字符串将打印到终端。 同样，也不必求值第二个操作数，因为一旦第一个操作数计算为`true`，则逻辑或始终为`true`。

```java
$ java ShortCircuit.java
Short circuit
Inside one
#############
Inside two
Pass

```

We see the result of the program.

## Java 关系运算符

关系运算符用于比较值。 这些运算符总是产生布尔值。

| 符号 | 含义 |
| --- | --- |
| `<` | 小于 |
| `<=` | 小于或等于 |
| `>` | 大于 |
| `>=` | 大于或等于 |
| `==` | 等于 |
| `!=` | 不等于 |

关系运算符也称为比较运算符。

`com/zetcode/Relational.java`

```java
package com.zetcode;

public class Relational {

    public static void main(String[] args) {

        System.out.println(3 < 4);
        System.out.println(3 == 4);
        System.out.println(4 >= 3);
        System.out.println(4 != 3);
    }
}

```

在代码示例中，我们有四个表达式。 这些表达式比较整数值。 每个表达式的结果为`true`或`false`。 在 Java 中，我们使用`==`比较数字。 （某些语言（例如 Ada，Visual Basic 或 Pascal）使用`=`比较数字。）

## Java 按位运算符

小数对人类是自然的。 二进制数是计算机固有的。 二进制，八进制，十进制或十六进制符号仅是数字符号。 按位运算符使用二进制数的位。 像 Java 这样的高级语言很少使用按位运算符。

| 符号 | 含义 |
| --- | --- |
| `~` | 按位取反 |
| `^` | 按位异或 |
| `&` | 按位与 |
| <code>&#124;</code> | 按位或 |

按位取反运算符分别将 1 更改为 0，将 0 更改为 1。

```java
System.out.println(~7); // prints -8
System.out.println(~ -8); // prints 7

```

运算符还原数字 7 的所有位。这些位之一还确定数字是否为负。 如果我们再一次对所有位取反，我们将再次得到 7。

按位，运算符在两个数字之间进行逐位比较。 仅当操作数中的两个对应位均为 1 时，位位置的结果才为 1。

```java
      00110
   &  00011
   =  00010

```

第一个数字是二进制符号 6，第二个数字是 3，结果是 2。

```java
System.out.println(6 & 3); // prints 2
System.out.println(3 & 6); // prints 2

```

按位或运算符在两个数字之间进行逐位比较。 如果操作数中的任何对应位为 1，则位位置的结果为 1。

```java
     00110
   | 00011
   = 00111

```

结果为`00110`或十进制 7。

```java
System.out.println(6 | 3); // prints 7
System.out.println(3 | 6); // prints 7

```

按位互斥或运算符在两个数字之间进行逐位比较。 如果操作数中对应位中的一个或另一个（但不是全部）为 1，则位位置的结果为 1。

```java
      00110
   ^  00011
   =  00101

```

结果为`00101`或十进制 5。

```java
System.out.println(6 ^ 3); // prints 5
System.out.println(3 ^ 6); // prints 5

```

## Java 复合赋值运算符

复合赋值运算符是由两个运算符组成的简写运算符。

```java
a = a + 3;
a += 3;

```

`+=`复合运算符是这些速记运算符之一。 以上两个表达式相等。 将值 3 添加到变量`a`中。

其他复合运算符是：

```java
-=   *=   /=   %=   &=   |=   <<=   >>=

```

下面的示例使用两个复合运算符。

`com/zetcode/CompoundOperators.java`

```java
package com.zetcode;

public class CompoundOperators {

    public static void main(String[] args) {

        int a = 1;
        a = a + 1;

        System.out.println(a);

        a += 5;
        System.out.println(a);

        a *= 3;
        System.out.println(a);
    }
}

```

我们使用`+=`和`*=`复合运算符。

```java
int a = 1;
a = a + 1;

```

`a`变量被初始化为 1。 使用非速记符号将值 1 添加到变量。

```java
a += 5;

```

使用`+=`复合运算符，将 5 加到`a`变量中。 该语句等于`a = a + 5;`。

```java
a *= 3;

```

使用`*=`运算符，将`a`乘以 3。该语句等于`a = a * 3;`。

```java
$ java CompoundOperators.java
2
7
21

```

这是示例输出。

## Java `instanceof`运算符

`instanceof`运算符将对象与指定类型进行比较。

`com/zetcode/InstanceofOperator.java`

```java
package com.zetcode;

class Base {}
class Derived extends Base {}

public class InstanceofOperator {

    public static void main(String[] args) {

        Base b = new Base();
        Derived d = new Derived();

        System.out.println(d instanceof Base);
        System.out.println(b instanceof Derived);
        System.out.println(d instanceof Object);
    }
}

```

在示例中，我们有两个类：一个基类和一个从基类派生的类。

```java
System.out.println(d instanceof Base);

```

此行检查变量`d`是否指向作为`Base`类实例的类。 由于`Derived`类继承自`Base`类，因此它也是`Base`类的实例。 该行打印正确。

```java
System.out.println(b instanceof Derived);

```

`b`对象不是`Derived`类的实例。 该行显示`false`。

```java
System.out.println(d instanceof Object);

```

每个类都有`Object`作为超类。 因此，`d`对象也是`Object`类的实例。

```java
$ java InstanceofOperator.java
true
false
true

```

This is the output of the program.

## Java `lambda`运算符

Java8 引入了 lambda 运算符（`->`）。

```java
(parameters) -> expression
(parameters) -> { statements; }

```

这是 Java 中 lambda 表达式的基本语法。 Lambda 表达式允许使用 Java 创建更简洁的代码。

参数类型的声明是可选的； 编译器可以从参数的值推断类型。 对于单个参数，括号是可选的； 对于多个参数，它们是必需的。 如果表达式主体中只有一个语句，则花括号是可选的。 最后，如果主体具有用于返回值的单个表达式，则`return`关键字是可选的； 需要大括号以指示表达式返回一个值。

`com/zetcode/LambdaExpression.java`

```java
package com.zetcode;

import java.util.Arrays;

public class LambdaExpression {

    public static void main(String[] args) {

        String[] words = { "kind", "massive", "atom", "car", "blue" };

        Arrays.sort(words, (String s1, String s2) -> (s1.compareTo(s2)));

        System.out.println(Arrays.toString(words));
    }
}

```

在示例中，我们定义了一个字符串数组。 使用`Arrays.sort()`方法和 lambda 表达式对数组进行排序。

```java
$ java LambdaExpression.java
[atom, blue, car, kind, massive]

```

这是输出。

Lambda 表达式主要用于定义功能接口的内联实现，即仅具有单个方法的接口。 接口是用于强制执行合同的抽象类型。

`com/zetcode/LambdaExpression2.java`

```java
package com.zetcode;

interface GreetingService {

    void greet(String message);
}

public class LambdaExpression2 {

    public static void main(String[] args) {

        GreetingService gs = (String msg) -> {
            System.out.println(msg);
        };

        gs.greet("Good night");
        gs.greet("Hello there");
    }
}

```

在示例中，我们借助 lambda 表达式创建了问候服务。

```java
interface GreetingService {

    void greet(String message);
}

```

接口`GreetingService`已创建。 实现此接口的所有对象都必须实现`greet()`方法。

```java
GreetingService gs = (String msg) -> {
    System.out.println(msg);
};

```

我们创建一个使用 lambda 表达式实现`GreetingService`的对象。 该对象具有将消息打印到控制台的方法。

```java
gs.greet("Good night");

```

我们调用对象的`greet()`方法，该方法将一条给定消息打印到控制台。

```java
$ java LambdaExpression2.java
Good night
Hello there

```

这是程序输出。

有一些常见的功能接口，例如`Function`，`Consumer`或`Supplier`。

`com/zetcode/LambdaExpression3.java`

```java
package com.zetcode;

import java.util.function.Function;

public class LambdaExpression3 {

    public static void main(String[] args) {

        Function<Integer, Integer> square = (Integer x) -> x * x;
        System.out.println(square.apply(5));
    }
}

```

该示例使用 lambda 表达式计算整数平方。

```java
Function<Integer, Integer> square = (Integer x) -> x * x;
System.out.println(square.apply(5));

```

`Function`是一个接受一个参数并产生结果的函数。 lambda 表达式的运算产生给定整数的平方。

## Java 双冒号运算符

Java8 中引入的双冒号运算符（`::`）用于创建对方法的引用。

`com/zetcode/DoubleColonOperator.java`

```java
package com.zetcode;

import java.util.function.Consumer;

public class DoubleColonOperator {

    private static void greet(String msg) {

        System.out.println(msg);
    }

    public static void main(String[] args) {

        Consumer<String> f = DoubleColonOperator::greet;
        f.accept("Hello there");
    }
}

```

在代码示例中，我们使用双冒号运算符创建对静态方法的引用。

```java
private static void greet(String msg) {

    System.out.println(msg);
}

```

我们有一个静态方法向控制台打印问候语。

```java
Consumer<String> f = DoubleColonOperator::greet;

```

`Consumer`是一个功能接口，表示接受单个输入参数且不返回结果的操作。 使用双冒号运算符，我们创建对`greet()`方法的引用。

```java
f.accept("Hello there");

```

我们使用`accept()`方法执行功能操作。

## Java 运算符优先级

运算符优先级告诉我们首先求值哪个运算符。 优先级对于避免表达式中的歧义是必要的。

以下表达式 28 或 40 的结果是什么？

```java
3 + 5 * 5

```

像数学中一样，乘法运算符的优先级高于加法运算符。 结果是 28。

```java
(3 + 5) * 5

```

要更改求值的顺序，可以使用括号。 括号内的表达式始终首先被求值。 上面的表达式的结果是 40。

## Java 运算符优先级列表

下表显示了按优先级排序的常见 Java 运算符（最高优先级优先）：

| 运算符 | 含义 | 关联性 |
| --- | --- | --- |
| `[] () .` | 数组访问，方法调用，对象成员访问 | 从左到右 |
| `++ -- + -` | 递增，递减，一元加减 | 从右到左 |
| `! ~ (type) new` | 否定，按位非，类型转换，对象创建 | 从右到左 |
| `* / %` | 乘法，除法，模 | 从左到右 |
| `+ -` | 加，减 | 从左到右 |
| `+` | 字符串连接 | 从左到右 |
| `<< >> >>>` | 移位 | 从左到右 |
| `< <= > >=` | 关系 | 从左到右 |
| `instanceof` | 类型比较 | 从左到右 |
| `== !=` | 相等 | 从左到右 |
| `&` | 按位与 | 从左到右 |
| `^` | 按位异或 | 从左到右 |
| <code>&#124;</code> | 按位或 | 从左到右 |
| `&&` | 逻辑与 | 从左到右 |
| <code>&#124;&#124;</code> | 逻辑或 | 从左到右 |
| `? :` | 三元 | 从右到左 |
| `=` | 简单赋值 | 从右到左 |
| `+= -= *= /= %= &=` | 复合赋值 | 从右到左 |
| `^= &#124;= <<= >>= >>>=` | 复合赋值 | 从右到左 |

Table: Operator precedence and associativity

表的同一行上的运算符具有相同的优先级。 如果我们使用具有相同优先级的运算符，则将应用关联规则。

`com/zetcode/Precedence.java`

```java
package com.zetcode;

public class Precedence {

    public static void main(String[] args) {

        System.out.println(3 + 5 * 5);
        System.out.println((3 + 5) * 5);

        System.out.println(! true | true);
        System.out.println(! (true | true));
    }
}

```

在此代码示例中，我们显示一些表达式。 每个表达式的结果取决于优先级。

```java
System.out.println(3 + 5 * 5);

```

该行打印 28。乘法运算符的优先级高于加法。 首先，计算`5*5`的乘积，然后加 3。

```java
System.out.println(! true | true);

```

在这种情况下，求反运算符的优先级高于按位或。 首先，将初始`true`值取反为`false`，然后`|`运算符将`false`和`true`组合在一起，最后给出`true`。

```java
$ java Precedence.java
28
40
true
false

```

This is the example output.

## Java 关联性规则

有时，优先级不能令人满意地确定表达式的结果。 还有另一个规则称为关联性。 运算符的关联性决定了具有相同优先级的运算符的求值顺序。

```java
9 / 3 * 3

```

此表达式的结果是 9 还是 1？ 乘法，删除和模运算符从左到右关联。 因此，该表达式的计算方式为：`(9 / 3) * 3`，结果为 9。

算术，布尔，关系和按位运算符都是从左到右关联的。 赋值运算符，三元运算符，递增，递减，一元正负，取反，按位 NOT，类型强制转换，对象创建运算符从右到左关联。

`com/zetcode/Associativity.java`

```java
package com.zetcode;

public class Associativity {

    public static void main(String[] args) {

        int a, b, c, d;
        a = b = c = d = 0;

        String str = String.format("%d %d %d %d", a, b, c, d);
        System.out.println(str);

        int j = 0;
        j *= 3 + 1;
        System.out.println(j);
    }
}

```

在该示例中，有两种情况，其中关联性规则确定表达式。

```java
int a, b, c, d;
a = b = c = d = 0;

```

赋值运算符从右到左关联。 如果关联性从左到右，则以前的表达式将不可能。

```java
int j = 0;
j *= 3 + 1;

```

复合赋值运算符从右到左关联。 我们可能期望结果为 1。但是实际结果为 0。由于有关联性。 首先求值右边的表达式，然后应用复合赋值运算符。

```java
$ java Associativity.java
0 0 0 0
0

```

This is the output of the program.

## Java 三元运算符

三元运算符`?:`是条件运算符。 对于要根据条件表达式选择两个值之一的情况，它是一个方便的运算符。

```java
cond-exp ? exp1 : exp2

```

如果`cond-exp`为`true`，则求值`exp1`并返回结果。 如果`cond-exp`为`false`，则求值`exp2`并返回其结果。

`com/zetcode/TernaryOperator.java`

```java
package com.zetcode;

public class TernaryOperator {

    public static void main(String[] args) {

        int age = 31;

        boolean adult = age >= 18 ? true : false;

        System.out.println(String.format("Adult: %s", adult));
    }
}

```

在大多数国家，成年是基于年龄的。 如果您的年龄超过特定年龄，则您已经成年。 对于三元运算符，这是一种情况。

```java
boolean adult = age >= 18 ? true : false;

```

首先，对赋值运算符右侧的表达式进行求值。 三元运算符的第一阶段是条件表达式求值。 因此，如果年龄大于或等于 18，则返回`?`字符后的值。 如果不是，则返回`:`字符后的值。 然后将返回值分配给成人变量。

```java
$ java TernaryOperator.java
Adult: true

```

31 岁的成年人是成年人。

## 计算素数

在下面的示例中，我们将计算素数。

`com/zetcode/PrimeNumbers.java`

```java
package com.zetcode;

public class PrimeNumbers {

    public static void main(String[] args) {

        int[] nums = { 0, 1, 2, 3, 4, 5, 6, 7, 8,
            9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28 };

        System.out.print("Prime numbers: ");

        for (int num : nums) {

            if (num == 0 || num == 1) {
                continue;
            }

            if (num == 2 || num == 3) {

                System.out.print(num + " ");
                continue;
            }

            int i = (int) Math.sqrt(num);

            boolean isPrime = true;

            while (i > 1) {

                if (num % i == 0) {

                    isPrime = false;
                }

                i--;
            }

            if (isPrime) {

                System.out.print(num + " ");
            }
        }

        System.out.print('\n');
    }
}

```

在上面的示例中，我们处理了几个运算符。 质数（或质数）是一个自然数，它具有两个截然不同的自然数除数：1 和它本身。 我们选择一个数字并将其除以 1 到所选数字的数字。 实际上，我们不必尝试所有较小的数字。 我们可以将数字除以所选数字的平方根。 该公式将起作用。 我们使用余数除法运算符。

```java
int[] nums = { 0, 1, 2, 3, 4, 5, 6, 7, 8,
    9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
    19, 20, 21, 22, 23, 24, 25, 26, 27, 28 };

```

我们将从这些数字计算素数。

```java
if (num == 0 || num == 1) {
    continue;
}

```

值 0 和 1 不被视为素数。

```java
if (num == 2 || num == 3) {

    System.out.print(num + " ");
    continue;
}

```

我们跳过 2 和 3 的计算。它们是质数。 请注意等式和条件或运算符的用法。 `==`的优先级高于`||`运算符。 因此，我们不需要使用括号。

```java
int i = (int) Math.sqrt(num);

```

如果我们仅尝试小于所讨论数字的平方根的数字，那么我们可以。

```java
while (i > 1) {
    ...
    i--;
}

```

这是一个`while`循环。 `i`是计算出的数字的平方根。 我们使用减量运算符将每个循环周期的`i`减 1。 当`i`小于 1 时，我们终止循环。 例如，我们有 9。9 的平方根是 3。我们将 9 的数字除以 3 和 2。这对于我们的计算就足够了。

```java
if (num % i == 0) {

    isPrime = false;
}

```

如果余数除法运算符针对任何`i`值返回 0，则说明该数字不是质数。

在 Java 教程的这一部分中，我们介绍了 Java 表达式。 我们提到了各种类型的运算符，并在表达式中描述了优先级和关联性规则。