Java 運算子簡介：邏輯、算術、位元

我們來談談Java中的運算：數值、邏輯、位元。這是學習如何程式設計絕對需要的理論基礎。

• Java中的運算子有哪些型別？
• JavaRush 課程中的 Java 運算符
• Java中的數字運算
• Java中的邏輯運算
• Java中的位元運算
• Java中操作的優先權
• 有用的使用範例

Java中的運算子有哪些型別？

對於任何操作，我們至少需要兩件事：

• 操作員;
• 操作數。

運算子的一個範例是兩個數字相加運算中的簡單加號。在這種情況下，相互相加的數字將成為操作數。因此，在運算子的幫助下，我們對一個或多個運算元進行運算。對兩個運算元執行運算的運算子稱為二元運算子。例如，將兩個數字相加。對單一運算元執行運算的運算子稱為一元運算子。例如，一元減號。

JavaRush 課程中的 Java 運算符

有幾個講座專門討論第一個任務的第四級Java 運算子- Java 語法。特別是條件運算符，例如 boolean。本課程包含 22 個任務，幫助您了解比較運算子、條件運算子和邏輯運算子的工作原理。

Java中的數字運算

程式設計師對數字執行的最常見操作是將數值指派給變數。她和接線生一樣，=你也很熟悉：

int a = 1;
int b = 2;
int c = 3;

還有算術運算。它們是使用二元算術運算子執行的： 表 1. 二元算術運算符 前四個運算符不應引起任何問題：一切都與數學中的相同。最後一個運算符，即除法的餘數，也不會做任何太複雜的事情。例如，如果我們將 24 除以 7，我們會得到 3 個整數和 3 個餘數。此運算符將傳回餘數：

System.out.println(24 % 7); // prints 3

以下是來自 Oracle 官方文件網站的範例： 程式將輸出以下內容： 1 + 2 = 3 3 - 1 = 2 2 * 2 = 4 4 / 2 = 2 2 + 8 = 10 10 % 7 = 3 Java 允許您組合：例如，運算子賦值和算術運算子。讓我們來看一個例子：

int x = 0;
x = x + 1; // x = 0 + 1 => x = 1
x = x + 1; // x = 1 + 1 => x = 2
x = x + 1; // x = 2 + 1 => x = 3

這裡我們定義了一個變數x並為其分配了零值。x接下來，在每一行中，我們為變數的目前值與 1 總和分配一個值x。每行的註解裡都有解釋。此過程稱為變數成長或遞增。上例中的遞增操作可以使用運算子組合替換為類似的操作：

int x = 0;
x += 1; // x = 0 + 1 => x = 1
x += 1; // x = 1 + 1 => x = 2
x += 1; // x = 2 + 1 => x = 3

您可以將賦值運算子與任何算術運算子結合使用：

int x = 0;
x += 10; // x = 0 + 10 => x = 10
x -= 5; // x = 10 - 5 => x = 5
x *= 5; // x = 5 * 5 => x = 25
x /= 5; // x = 25 / 5 => x = 5
x %= 3; // x = 5 % 3 => x = 2;

讓我們示範一下最後一個範例的工作原理： 除了二元運算子之外，Java 還有一元算術運算子。 表 2. 一元算術運算子： 一元加號和減號的範例：

int x = 0;
x = (+5) + (+15); // Parentheses for clarity, it is possible without them
System.out.println("x = " + x);

int y = -x;
System.out.println("y = " + y);

自增和自減操作本質上很簡單。在第一種情況下，變數增加 1，在第二種情況下，變數減少 1。範例如下：

int x = 9;
x++;
System.out.println(x); // 10

int y = 21;
y--;
System.out.println(y); // 20

這些操作有兩種類型 - 後綴和前綴。在第一種情況下，運算子寫在變數之後，在第二種情況下，運算子寫在變數之前。唯一的區別在於何時執行遞增或遞減操作。範例和說明如下表所示。假設我們有一個變數：

int a = 2;

然後： 表 3. 遞增-遞減運算子： 示範： 除了算術運算之外，還有（兩個數字的）比較運算。結果總是 true 或 false ( true / false )。 表 4. 比較運算符 例子：

int a = 1;
int b = 2;

boolean comparisonResult = a == b;
System.out.println("a == b :" + comparisonResult);

comparisonResult = a != b;
System.out.println("a != b :" + comparisonResult);

comparisonResult = a > b;
System.out.println("a >  b :" + comparisonResult);

comparisonResult = a >= b;
System.out.println("a >= b :" + comparisonResult);

comparisonResult = a < b;
System.out.println("a <  b :" + comparisonResult);

comparisonResult = a <= b;
System.out.println("a <= b :" + comparisonResult);

示範：

Java中的邏輯運算

讓我們來看看它們各自的邏輯運算和真值表：

• 取反運算 ( NOT);
• 並運算，邏輯與 ( AND)；
• 或運算，邏輯或 ( OR)；
• 模加運算，異或 ( XOR)。

否定運算符是一元運算符，適用於單一操作數。所有其他操作都是二進制的。讓我們考慮一下這些運算的真值表。這裡0相當於Java 中的false，1相當於true。 表 5. 否定運算子真值表 (NOT) 表 6. 合取運算子 (AND) 的真值表 表 7. 或運算子 (OR) 的真值表 表 8. 模加運算子 (XOR) 的真值表 Java也有同樣的邏輯運算：

• !— 否定運算子；
• &&— 邏輯 AND 運算子（短）；
• ||— 邏輯或運算子（短）；
• &——位元與運算子；
• |— 按位或運算符；
• ^— 依位元異或運算子。

以下讓我們進一步看看位元運算子和速記運算子之間的區別，同時讓我們將所有真值表轉換為 Java 程式碼：

public class LogicDemo {

   public static void main(String[] args) {
    notExample();
    andExample();
    orExample();
    xorExample();
   }

   public static void notExample() {
    System.out.println("NOT EXAMPLE:");
    System.out.println("NOT false = " + !false);
       System.out.println("NOT true  = " + !true);
    System.out.println();
   }

   public static void andExample() {
    System.out.println("AND EXAMPLE:");
    System.out.println("false AND false = " + (false & false));
    System.out.println("false AND true  = " + (false & true));
    System.out.println("true  AND false = " + (true & false));
    System.out.println("true  AND true  = " + (true & true));
    System.out.println();
   }

   public static void orExample() {
    System.out.println("OR EXAMPLE:");
    System.out.println("false OR false = " + (false | false));
    System.out.println("false OR true  = " + (false | true));
    System.out.println("true  OR false = " + (true | false));
     System.out.println("true  OR true  = " + (true | true));
    System.out.println();
   }

   public static void xorExample() {
    System.out.println("XOR EXAMPLE:");
    System.out.println("false XOR false = " + (false ^ false));
    System.out.println("false XOR true  = " + (false ^ true));
    System.out.println("true  XOR false = " + (true ^ false));
    System.out.println("true  XOR true  = " + (true ^ true));
    System.out.println();
   }
}

程式會顯示： NOT Examples: NOT false = true NOT true = false AND Examples: false AND false = false false AND true = false true AND false = false true AND true = true OR Examples: false false = false true AND true = true OR Examples: false false = false = true true OR false = true true OR true = true XOR 範例： false XOR false = false false XOR true = true true XOR false = true true XOR true = false 邏輯運算子僅適用於boolean變數。在我們的例子中，我們將它們直接應用於值，但您也可以將它們與boolean變數一起使用： 以及boolean表達式： 現在，我們有簡寫運算子 ( &&, ||) 和類似的位元運算子 ( &, |)。它們之間有什麼區別？首先，位元可以套用於整數。我們稍後再討論這個問題。其次，有些是縮寫的，而有些則不是。要了解縮寫是什麼樣子，讓我們來看看表達式：

false AND x = ?
true OR x = ?

這x可以採用任何布林值。而一般來說，根據邏輯和真值表的規律，無論真假x ，第一個表達式的結果將為假，而第二個表達式的結果將為真。看。 有時可以根據第一個操作數計算表達式的結果。&&這就是縮寫運算子和的差別||。在與上述類似的表達式中，它們不會計算第二個運算元的值。這是一個小例子： 對於簡寫運算符，不計算表達式的第二部分。但只有當表達式的結果從第一個運算元中已經顯而易見時，才會發生這種情況。

Java中的位元運算

好了，我們來到了最有趣的部分：位元運算。顧名思義，這些是對位執行的操作。但在我們深入討論這個主題之前，有必要先討論相關領域。

二進制數字系統中數字的表示

數字與程式中的任何其他資訊一樣，以二進位代碼儲存在電腦記憶體中。二進位代碼是一組零和一。每個零或一代表一個稱為位元的資訊單元。

根據維基百科：

位元（來自英文binary digital——二進制數；也是一個文字遊戲：英文bit——片、粒子）是資訊量的計量單位。1 位元資訊是一種符號或訊號，可以有兩種意義：開或關、是或否、高或低、帶電或不帶電；在二進位系統中它是 1（一）或 0（零）。

位元運算子處理什麼類型的資料？

Java 中的位元運算僅對整數執行。整數作為一組位元儲存在電腦記憶體中。我們可以說電腦將任何資訊轉換為二進位數字系統（一組位元），然後才與其互動。但是二進制數字系統是如何運作的呢？在十進制中，我們只有 10 個符號：0、1、2、3、4、5、6、7、8、9。我們使用這些符號來計數。9 之後是 10，19 - 20 之後，99 - 100 之後，749 - 750 之後。也就是說，我們使用可用的 10 個符號的組合，可以使用它們來計數“從零到午餐”。在二進制數字系統中，不是十個符號，而是只有兩個 - 0、1。但是，按照與十進制系統中相同的原理將這些符號組合起來，我們就可以無限計數。 讓我們示範一下十進制和二進制從 0 到 15 的計數： 正如你所看到的，一切都沒有那麼複雜。除了位元之外，還有其他熟悉的資訊單位——位元組、千位元組、兆位元組、千兆位元組等。您可能知道1 個位元組有 8 個位元。這是什麼意思？這意味著一行8位元佔用1個位元組。以下是位元組的範例：

00000000 - 1 byte
10110010 - 1 byte
01011011 - 1 byte

一個位元組中可能的非重複位元組合數量為 256 (2 ⁸ = 256)。但讓我們回到 Java。有這樣一種整數資料型態— byte。這種類型可以取-128到127之間的值，而電腦記憶體中的一個數字正好佔用8位，即1個位元組。1 個此類數字正好佔用 1 個byte電腦記憶體。這裡的名字重合併非偶然。我們記得，1 個位元組可以儲存 256 個不同的值。一種類型的數字byte可以呈現 256 個不同的值（128 個負值、127 個正值和 1 個零）。每個數字值byte都有一組唯一的八位元。不僅 type 是這種情況byte，所有整型類型也是如此。給出的類型byte作為最小的範例。下表顯示了所有 Java 整數類型及其佔用的記憶體空間： 考慮類型int。它可以儲存 2147483648 個負值、2147483647 個正值和 1 個零。全部的：

2147483648 + 2147483647 + 1 = 4294967296.

此類型在電腦記憶體中佔用 32 位元。一組 32 個 0 和 1 的可能組合數為：

232 = 4294967296.

與該類型可以容納的值的數量相同int。這只是演示了一種資料類型的取值範圍與其大小（記憶體中的位數）之間的關係。Java中任何類型的任何數字都可以轉換為二進位。讓我們看看使用 Java 語言可以多麼輕鬆地完成此操作。我們將從 type 的例子中學習int。這種類型有它自己的包裝類 - Integer。他有一個toBinaryString，可以為我們完成所有工作： 瞧 - 沒那麼複雜。但仍有一些事情需要澄清。int該數字需要 32 位元。但是，當我們在上面的範例中列印數字 10 時，我們在控制台中看到 1010，這是因為沒有列印前導零。如果顯示它們，我們將在控制台中看到 000000000000000000000000000001010，而不是 1010。但為了易於理解，所有前導零都被省略。沒那麼難，直到你問自己：負數怎麼樣？它只感知二進制系統中的信息。原來減號也需要寫成二進位碼。這可以使用直接程式碼或補充程式碼來完成。

直接程式碼

一種在二進制數系統中表示數字的方法，其中最高有效位（最左邊的位）分配給數字的符號。如果數字是正數，則最左邊的位元寫入 0，如果是負數，則寫入 1。 讓我們以 8 位數為例來看： 這個方法很簡單，原則上也容易理解。然而，它也有缺點：執行數學運算困難。例如，負數和正數相加。除非進行額外的操作，否則它們無法折疊。

附加程式碼

透過使用附加代碼，您可以避免直接代碼的缺點。有一個簡單的演算法可以取得數字的附加程式碼。讓我們嘗試獲取數字-5 的附加代碼。讓我們用二進制數係統中的補碼來表示這個數字。步驟 1. 我們使用直接代碼來獲得負數的表示。對於 -5，則為 10000101。步驟 2. 反轉除符號數字以外的所有數字。讓我們將所有零替換為 1，並將除了最左邊的位元之外的所有位置都替換為 0。

10000101 => 11111010

步驟 3. 將結果值加一：

11111010 + 1 = 11111011

準備好。我們使用二進制補碼得到了二進制數係統中-5 的值。這對於理解以下內容非常重要，因為 Java 使用二進制補碼來以位元形式儲存負數。

位元運算的類型

現在我們已經完成了所有的介紹，讓我們來談談Java中的位元運算。對整數執行位元運算，其結果為整數。在此過程中，數字被轉換為二進制，對每一位執行運算，然後結果被轉換回十進制。操作列表如下表所示： 如我們已經發現的，數字可以表示為一組位元。位元運算精確地對這種表示的每一位執行運算。讓我們來NOT，AND，OR，XOR。回想一下，我們最近只查看了邏輯運算元的真值表。在這種情況下，相同的操作會應用於整數的每一位。

位元一元運算子 NOT ~

該運算符將所有零替換為 1，並將所有 1 替換為零。假設我們有十進制數 10。在二進位中，這個數字是 1010。如果我們對這個數字應用一元按位求反運算符，我們會得到以下結果： 讓我們看看它在 Java 程式碼中的樣子：

public static void main(String[] args) {
   int a = 10;

   System.out.println(" a = " + a + "; binary string: " + Integer.toBinaryString(a));
   System.out.println("~a = " + ~a + "; binary string: " + Integer.toBinaryString(~a));
}

現在讓我們看看控制台中顯示的內容： 在第一行中，我們獲得了不含前導零的二進位數字系統中的值。儘管我們看不到它們，但它們就在那裡。第二行證明了這一點，其中所有位元都轉換為相反的位元。這就是為什麼我們看到這麼多領先單位。這些是以前的前導零，在第一行列印時被編譯器忽略。這是一個小程序，為了清晰起見，它還顯示前導零。

位元與運算符

此運算符適用於兩個數字。AND它在每個數字的位元之間執行操作。讓我們來看一個例子： 這個運算是對兩個數字執行的。Java 程式碼中的範例：

按位或運算符

OR 適用於兩個數字。它在每個數字的位元之間執行 OR 運算： 現在讓我們看看在 IDEA 中會是什麼樣子：

位元運算、異或（XOR）

讓我們看一下相同的範例，但使用了新的操作： 範例程式碼：

位元左移

此運算子適用於兩個操作數，即在運算中x << y，數字的位元x會左移y。這是什麼意思？我們來看運算的例子，10 << 1 運算的結果是十進制的20。從上圖可以看出，所有位元都左移 1。在此操作期間，最高有效位元（最左邊的位元）的值會遺失。最低有效位元（最右邊的位元）用零填滿。對於這次手術有什麼想說的嗎？

1. 透過將數字的位向左移動X一位N，我們將該數字乘以X2 ^N。

   這是一個例子：

2. 但！如果值為 1 的位元佔據最左邊的位置，則數字的符號可能會改變。

3. 如果無限左移，數字將簡單地變為 0。讓我們示範第 2 點和第 3 點：

位元右移

此運算符適用於兩個操作數。那些。在運算中x >> y，數字的位元x將y向右移動位置。讓我們來看另一個例子。我們來示意性地分析一下操作過程10 >> 1。讓我們將數字 10 的所有位元向右移動一位： 在移位操作期間，我們遺失了右邊的位元。他們就這樣消失了。最左邊的位子是數字的符號（0 為正，1 為負）。因此，最終值中的位置與原始數字中的位置相同。以負數為例： 最右邊的位元遺失，最左邊的位從原始數字複製而來，作為該數字的榮譽符號。如何在IDEA中完成這一切？原則上，沒什麼複雜的，只需拿走它並移動它： 現在。對於向右移動的數字你能說什麼？它們可以被 2 整除。每次向右移動一位，我們將原始數字除以 2。如果該數字不能被 2 整除，結果將向負無窮大（向下）捨去。但這只有在我們將位元精確移位 1 時才有效。如果移位 2 位，則除以 4。移位 3 位，則除以 8。移位 4 位，則除以 16。看到了嗎？2 的方...當我們將數字X向右移動N一位時，我們將該數字除以X2 的 2 次方N。示範：

public class BitOperationsDemo {

   public static void main(String[] args) {

    for (int i = 1; i <= 10; i++) {

        int shiftOperationResult = 2048 >> i;
        int devideOperationResult = 2048 / (int) Math.pow(2, i);


           System.out.println(shiftOperationResult + " - " + devideOperationResult);
    }

   }

}

這裡發生了什麼事？

1. 變數 i 從 1 遞增到 10 的循環。

2. 每次迭代我們計算 2 個值：

• shiftOperationResult我們將數字 2048 右移 i 位的結果寫入變數；

• devideOperationResult我們將數字 2048 除以 2 的 i 次方的結果寫入變數。

3. 我們成對顯示獲得的兩個值。

程式執行結果如下： 1024 - 1024 512 - 512 256 - 256 128 - 128 64 - 64 32 - 32 16 - 16 8 - 8 4 - 4 2 - 2

按位右移並補零

正常右移會保留數字的符號（最高有效位元保留其值），而零填充右移則不會。且最高有效位元以零填充。讓我們看看它是什麼樣子的：

Java中操作的優先權

與數學一樣，Java 也有運算優先權。下表顯示了我們考慮的操作的優先順序（從最高到最低）。

有用的使用範例

確定數字的奇偶性

尋找數組中的最大元素

要找到最小元素，只需更改正確位置的比較符號。