1. 介紹
Java 中整數型別的基礎
當在 Java 中處理數字時，最基本的資料型別之一就是「整數型別」(int)。它是一種原始型別，常用於程式內的數值計算，能提供快速且記憶體效率高的處理。另一方面，Java 也提供了一個名為 Integer 的類別。這被稱為 封裝類別（wrapper class），設計目的是將 int 值以物件方式處理，符合 Java 的物件導向哲學。雖然這兩種型別看起來相似，但在用途與行為上有明顯差異。因此，Java 初學者常會想：「int 與 Integer 有什麼差別？」或「應該如何適當使用它們？」
為什麼要學習 Integer 類別？
在 Java 中有許多情境—例如使用集合框架（如 List 或 Map）、處理 null 值或使用泛型—原始型別 int 不適用。在這些情況下，Integer 類別變得不可或缺，因此了解其基礎非常重要。Integer 類別還提供許多實用方法，例如字串與數字之間的轉換、比較以及位元運算。掌握這些方法能讓你寫出更健全、可讀性更高的程式碼。本文聚焦於 Integer 類別，說明它與 int 的差異、如何使用以及實際應用案例。無論你是 Java 初學者還是已有經驗，這裡都能找到有用資訊—請繼續閱讀！
2. Integer 類別是什麼？
作為封裝類別的角色
Java 的 Integer 類別是一個 封裝類別，允許將原始型別 int 當作物件處理。正如名稱所示，封裝「包裝」某物——在此情況下，它將原始的 int 值封裝進 Integer 「盒子」中，讓它能以物件形式使用。舉例來說，Java 集合（如 List 與 Map）只能處理物件。由於原始型別 int 無法直接使用，必須使用 Integer。
List<Integer> numbers = new ArrayList<>();
numbers.add(10); // The int value 10 is automatically converted to Integer and stored
透過將 int 值轉換（封裝）為物件形式，你可以無縫地使用許多 Java API 與框架。
自動裝箱與拆箱
自 Java 5 起，便引入了名為「自動裝箱」與「自動拆箱」的便利功能。
- Autoboxing :
int值會自動轉換為Integer物件 - Unboxing :
Integer物件會自動轉換為int值Integer num = 100; // Autoboxing int result = num + 50; // Unboxing occurs for the calculation
這意味著開發者不需要寫明確的轉換程式碼—Java 會自動處理轉換，讓程式碼更簡潔易讀。
然而，如果嘗試拆箱 null 值，將拋出 NullPointerException，請小心。
Integer value = null;
int x = value; // This throws an exception
Integer 的重要性
Integer 類別不僅僅是 int 的替代品。作為物件，它具有以下特性：
- 可以賦值為
null，以表示「未設定」的狀態 - 內建多種方法，提供靈活的操作
- 可用於集合及其他以物件為基礎的結構
簡而言之，在 Java 的物件導向環境中，許多情境下 Integer 比 int 更適合。
3. Integer 類別的主要欄位與常數
Java 的 Integer 類別定義了多個 實用常數 與 用於取得數值資訊的欄位。使用這些可以提升程式碼的可讀性與可維護性。以下列出一些最常用的欄位。
MAX_VALUE 與 MIN_VALUE
Integer.MAX_VALUE 與 Integer.MIN_VALUE 是代表 int 型別能容納的 最大 與 最小 值的常數。
MAX_VALUE: 2,147,483,647 (2 的 31 次方減 1)MIN_VALUE: -2,147,483,648 (負 2 的 31 次方)
這些常用於範圍檢查或防止溢出，使其成為 安全數值處理 的關鍵。
int max = Integer.MAX_VALUE;
int min = Integer.MIN_VALUE;
System.out.println("Max value: " + max); // 2147483647
System.out.println("Min value: " + min); // -2147483648
SIZE 和 BYTES
SIZE 和 BYTES 是表示 int 類型使用的 位元數 和 位元組數 的常數。
Integer.SIZE: 32（位元數）Integer.BYTES: 4（位元組數）
這些常用於處理二進位資料或系統程式設計情境，例如計算資料大小或用於加密目的。
System.out.println("Number of bits in int: " + Integer.SIZE); // 32
System.out.println("Number of bytes in int: " + Integer.BYTES); // 4
TYPE 欄位
Integer.TYPE 是一個靜態欄位，返回 int 類型的 Class 物件。它有時用於 進階程式設計技巧，例如反射或泛型。
Class<?> clazz = Integer.TYPE;
System.out.println(clazz.getName()); // int
雖然在日常開發中不常使用，但如果你對 Java 內部機制或框架開發感興趣，了解它是很好的。
所有這些常數都被定義為 static final，意味著你可以直接從 Integer 類存取它們，而不必建立實例。了解這些與型別相關的常數是預防錯誤並提升 Java 性能的良好第一步。
4. Integer 類別的關鍵方法
Integer 類別不僅僅是 int 的包裝器。它提供許多實用的方法，用於字串轉換、數值比較、位元運算等，對日常 Java 開發非常有用。以下將按類別介紹最常用的方法。
轉換方法
parseInt()
parseInt() 是一個靜態方法，將字串轉換為 int 值。它主要用於處理使用者輸入或來自外部檔案的資料，需將其作為數字處理。
String str = "123";
int number = Integer.parseInt(str); // 123
* 若傳入非數值字串，將拋出 NumberFormatException，因此使用 try-catch 更安全。
valueOf()
valueOf() 是一個方法，將字串或 int 值轉換為 Integer 物件。與 parseInt() 不同，回傳型別為 Integer，而非 int。
Integer num1 = Integer.valueOf("456");
Integer num2 = Integer.valueOf(789);
Integer.valueOf() 會重複使用 -128 到 127 之間的快取物件，比使用 new 建立新實例更有效率。
顯示與轉換方法
toString()
toString() 是一個方法，將數值回傳為字串。常用於字串連接或顯示值。
int number = 100;
String str = Integer.toString(number); // "100"
你也可以用它將數值轉換為其他進位制，例如二進位或十六進位。
System.out.println(Integer.toBinaryString(10)); // "1010"
System.out.println(Integer.toHexString(255)); // "ff"
比較方法
compareTo()
compareTo() 是一個方法，比較兩個 Integer 物件並回傳一個整數，表示它們的相對順序。
Integer a = 10;
Integer b = 20;
int result = a.compareTo(b); // -1 (returns a negative value if a < b)
它常與 Collections.sort 等方法一起使用。
equals()
equals() 是一個方法，檢查兩個值是否相等。== 運算子比較的是參考，故建議使用 equals() 來比較物件值。
Integer x = 100;
Integer y = 100;
System.out.println(x.equals(y)); // true
位元運算方法
在所有 Java 類別中，Integer 類別獨特地提供了廣泛的 低階位元運算 支援。
bitCount()
此方法 返回給定 int 值中被設定為 1 的位元數。
int count = Integer.bitCount(15); // 15 in binary is 1111 → 4 bits set to 1
highestOneBit()
此方法 返回給定 int 值中僅保留最高位元為 1 的值。
int highest = Integer.highestOneBit(10); // 10 (1010) → 8 (1000)
在涉及位元運算的最佳化中非常有用。
其他實用方法
Integer.reverse(int)：反轉位元的順序Integer.signum(int)：返回符號（正數: 1，負數: -1，零: 0）Integer.hashCode()：返回雜湊碼（在使用集合時很重要）
數字在 Java 中無處不在。只要了解這些方法，就能寫出 優雅且高效的程式碼。尤其是轉換、比較與位元運算方法在實務中常被使用，務必熟練掌握。
5. 在 int 與 Integer 之間的選擇
在 Java 中，有兩種表示整數的型別：int 與 Integer。雖然可以相互轉換，但 不當使用可能導致效能問題或意外錯誤。讓我們檢視它們的特性，並了解在各種情境下如何選擇合適的型別。
效能差異
int 是原始型別，佔用固定記憶體大小（4 位元組），且在計算上非常快速。相對地，Integer 是物件型別，作為實例存放於堆積區，並提供方法與額外功能。
int a = 10;
Integer b = 10;
即使指派相同的值，內部處理方式仍不同。對於大量計算或迴圈而言，使用 int 速度更快且更省記憶體。
範例：迴圈中的效能差異
long startTime = System.nanoTime();
int sum = 0;
for (int i = 0; i < 1000000; i++) {
sum += i;
}
long endTime = System.nanoTime();
System.out.println("Time for int: " + (endTime - startTime) + " ns");
若使用 Integer 執行相同操作，會產生裝箱與拆箱的開銷，導致速度慢上數倍。
可為 null 與例外處理的差異
int 不能被指派為 null。因此在需要表示「無值」或「未設定」的情況下不適用。
Integer value = null;
if (value == null) {
System.out.println("Value is unset");
}
使用 Integer 時，您可以 明確處理 null，因此在表單驗證或資料庫取回可能缺少值的情境中相當理想。
然而，將 null 的 Integer 拆箱為 int 會拋出 NullPointerException，需特別留意。
與集合的相容性
Java 的集合（如 List 與 Map）只能儲存物件。因此無法直接使用 int，必須改用 Integer。
List<Integer> numbers = new ArrayList<>();
numbers.add(100); // int → Integer via autoboxing
此外，在使用泛型時，不能將原始型別作為類型參數，必須使用 Integer。
小結：選擇指引
| Use Case | Recommended Type | Reason |
|---|---|---|
| Mainly numeric calculations | int | Faster processing and better memory efficiency |
| Need to represent presence or absence of a value | Integer | Can handle null |
| Working with collections or generics | Integer | Object type required |
| Using numbers as Map keys | Integer | int can’t be used |
基本上，記住：「速度使用 int，彈性使用 Integer」。
6. 常見錯誤與處理方式
NullPointerException
原因：
因為 Integer 是物件型別，可以被指派為 null，但 若嘗試將 null 的 Integer 拆箱為 int，就會拋出 NullPointerException。
Integer value = null;
int x = value; // Exception thrown here
解決方案：
在拆箱前務必先檢查是否為 null。
if (value != null) {
int x = value;
} else {
int x = 0; // Assign a default value
}
或者，也可以使用 Optional（Java 8 以上）安全地處理：
int x = Optional.ofNullable(value).orElse(0);
NumberFormatException
原因：
當使用 Integer.parseInt() 或 Integer.valueOf() 轉換 非數字字串 時，會拋出此例外。
String input = "abc";
int num = Integer.parseInt(input); // NumberFormatException
解決方案：
事先檢查輸入是否為數字，通常可使用正規表達式。
if (input.matches("-?\d+")) {
int num = Integer.parseInt(input);
} else {
System.out.println("Not a numeric value");
}
同時，使用 try‑catch 來處理例外，確保處理過程安全。
try {
int num = Integer.parseInt(input);
} catch (NumberFormatException e) {
System.out.println("Invalid number format: " + input);
}
錯誤使用 == 與 equals()
原因：
在比較兩個 Integer 物件時使用 ==，實際上是 比較它們的參考位址，而非值本身。因此即使值相同，只要是不同的物件，就可能回傳 false。
Integer a = new Integer(128);
Integer b = new Integer(128);
System.out.println(a == b); // false (different references)
System.out.println(a.equals(b)); // true (same value)
* 對於介於 -128 到 127 之間的值，物件會被快取，所以 == 可能會回傳 true。但這取決於實作細節。
解決方案：
永遠使用 .equals() 來比較兩個 Integer 物件。
if (a.equals(b)) {
System.out.println("Values are equal");
}
也可以在拆箱後比較它們的原始 int 值。
if (a.intValue() == b.intValue()) {
System.out.println("Equal as int values");
}
忽略溢位
原因：
int 與 Integer 只能處理 32 位元的數值 (±2,147,483,647)。若超出此範圍，將無法正確運作。
int a = Integer.MAX_VALUE;
int b = a + 1;
System.out.println(b); // -2,147,483,648 (wraps around to negative)
解決方案：
必要時考慮使用 long 或 BigInteger，並時時留意其上限。
小結
雖然 Integer 使用方便且彈性高，但它伴隨著 關於 null、參考以及型別轉換的諸多限制。對於 Java 初學者而言，了解這些例外產生的原因尤為重要。若事先掌握這些常見陷阱，就能避免錯誤，撰寫更穩定的程式碼。
7. 實作範例：Integer 類別的應用方式
此時，你應該已對 Integer 類別的特性、差異與重要注意事項有相當的了解。接下來，我們來看看一些 實務上的使用案例，說明 Integer 常被如何運用。
將使用者輸入轉換為數字
在 Web 與桌面應用程式中，使用者的輸入通常以 String 形式取得。然而，當處理年齡、數量等欄位時，往往需要將其轉換為數字，這時 Integer 就非常有幫助。
String input = "25"; // User input as a string
try {
Integer age = Integer.valueOf(input); // Convert String → Integer
System.out.println("Age: " + age);
} catch (NumberFormatException e) {
System.out.println("Invalid input");
}
透過驗證輸入是否為合法數字並處理錯誤，即可實現 健全的使用者輸入處理。
管理設定值與環境變數
常見的做法是 將系統或設定值以字串讀取後再轉換為整數。例如使用 System.getProperty() 時，通常需要解析其回傳結果。
String maxConn = System.getProperty("app.maxConnections", "100");
int max = Integer.parseInt(maxConn);
System.out.println("Max connections: " + max);
在此情境下，提供合理的預設值並允許彈性的設定變更是相當重要的。
在集合中使用數字
當你需要在集合（如 List）中處理數字時，必須使用 Integer 而非 int。例如，你可能會暫時儲存使用者輸入的一系列 ID。
List<Integer> ids = new ArrayList<>();
ids.add(101);
ids.add(205);
ids.add(309);
for (Integer id : ids) {
System.out.println("Processing ID: " + id);
}
感謝 autoboxing（自動裝箱），int 轉換為 Integer 會自動完成，讓您能撰寫簡潔的程式碼，而不必擔心手動轉換。
使用位元運算進行旗標管理
Integer 類別提供豐富的位元操作方法，對於 低階旗標管理與狀態轉換 十分有用。
int flags = 0;
// Set the 1st bit
flags |= 0b0001;
// Set the 2nd bit
flags |= 0b0010;
// Check if the 2nd bit is set
boolean isSet = (flags & 0b0010) != 0;
System.out.println("The 2nd bit is: " + (isSet ? "ON" : "OFF"));
您也可以使用 Integer.toBinaryString(flags) 來 視覺化旗標狀態：
System.out.println("Current flag state: " + Integer.toBinaryString(flags));
與資料庫的互動
在使用 JDBC 或類似方式與資料庫互動時，對數值欄位使用 Integer（而非 int）可 安全地處理 null 值。
ResultSet rs = stmt.executeQuery("SELECT age FROM users WHERE id = 1");
if (rs.next()) {
Integer age = (Integer) rs.getObject("age");
System.out.println(age != null ? "Age: " + age : "Age not set");
}
因為基本型別 int 無法為 null，此處應選擇 Integer。
小結
Integer 類別不僅是 int 的包裝器——它在 彈性資料處理與確保實務開發安全 中扮演關鍵角色。特別適用於以下情境：
- 將使用者輸入或外部設定轉換為數字
- 處理可能為
null的資料 - 在集合中儲存整數
- 使用位元運算管理狀態
精通 Integer 後，您可以撰寫 更具延展性、可維護性與穩定性 的程式碼。
8. 結論
Java 的 Integer 類別不只是 int 的替代品——它是 與 Java 物件導向特性緊密相關的關鍵類別。在本文中，我們以易於初學者理解的方式說明了以下重點，同時涵蓋實務層面的應用：
Integer 類別的優勢是什麼？
- 因為它可以被視為 物件，因此能處理
null值並可用於集合 - 內建 許多便利的方法（字串轉換、比較、位元運算等）
- 與
System.getProperty()以及資料庫操作相容性佳，能實現彈性設計 - 物件快取 與 autoboxing 讓程式碼更簡潔、易於撰寫
這些都是原始型別 int 所無法提供的優勢。
但也有重要的注意事項
- 對
null的Integer進行拆箱會拋出NullPointerException - 使用
==運算子可能無法如預期比較值 - 在效能方面，
int在大規模數值運算上表現更佳
若未了解上述要點，可能會導致意外的錯誤或效能問題。
正確選擇型別是關鍵
| Use Case | Recommended Type | Reason |
|---|---|---|
| When fast numeric processing is required | int | Superior memory efficiency and calculation speed |
When data may be null | Integer | Supports nullability and can be handled safely |
| When used with collections or generics | Integer | Because an object type is required |
| When using numbers as Map keys | Integer | int cannot be used |
總結來說，int 與 Integer 不僅是不同的型別，還應依據設計目標與使用情境適當選擇。
最後的思考
了解 Integer 不僅是處理 Java 資料型別的基礎，也有助於培養在 物件導向設計、例外處理與效能優化 方面更深入的程式設計能力。由於整數型別的使用相當普遍，早期對其有完整的認識將成為您未來 Java 開發旅程中的重要資產。
常見問題 (FAQ)
Q1. int 與 Integer 有何差異？
A. int 是 Java 的原始資料型別，用於有效且快速地處理整數值。Integer 是一個 包裝類別，讓你可以把 int 當作物件來使用，從而支援 null 值並使用各種方法。例如，在將值存入集合或區分已設定與未設定的值時，Integer 更為合適。
Q2. parseInt() 與 valueOf() 有何差異？
A. 兩者皆將字串轉換為數字，但回傳的型別不同：
parseInt(String s)→ 回傳int（原始型別）valueOf(String s)→ 回傳Integer（物件型別）
依需求選擇。若需要物件或要處理 null 值，valueOf() 更實用。
Q3. 為什麼不應該使用 == 來比較 Integer 物件？
A. == 運算子 比較物件參考，而非實際的值。即使兩個物件的值相同，只要不是同一個實例，就可能得到 false。對於 128 以上的值，物件快取不會生效，容易產生意外結果。比較值時應使用 .equals()。
Integer a = 128;
Integer b = 128;
System.out.println(a == b); // false (different references)
System.out.println(a.equals(b)); // true (same value)
Q4. 若將 null 指派給 Integer 會發生什麼事？
A. 由於 Integer 是物件，你可以將 null 指派給它。但若在 null 的情況下將其轉換（拆箱）為 int，會拋出 NullPointerException。
Integer val = null;
int num = val; // Exception thrown here
請務必先檢查 null，或使用 Optional 以提升程式安全性。
Q5. 如何取得 Integer 的最大值與最小值？
A. 在 Java 中，你可以使用 Integer.MAX_VALUE 與 Integer.MIN_VALUE 直接取得這些上限與下限。
System.out.println(Integer.MAX_VALUE); // 2147483647
System.out.println(Integer.MIN_VALUE); // -2147483648
這在範圍檢查與防止溢位時非常有用。
Q6. 為什麼在集合中不能使用 int？
A. Java 的集合（如 List、Map）只能處理物件，無法直接使用原始型別。因此必須使用 Integer 來代替。
List<Integer> list = new ArrayList<>();
list.add(123); // int is automatically converted to Integer
Q7. 效能上，int 與 Integer 哪個較好？
A. 在需要高速計算或在迴圈中大量處理數字時，int 的速度更快且記憶體使用更有效率。Integer 雖然使用起來較方便且彈性更高，但額外的物件產生與裝箱/拆箱會使其在重負載情況下表現較差。
