# 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 表達式。 我們提到了各種類型的運算符，并在表達式中描述了優先級和關聯性規則。