Course Module 1 no mu - Lecture: 詳細包裝器類

1.`Integer`類

Integer另一個好處是它是一個類，這意味著它可以有字段和方法。而且，當然，它有它們。很多——幾十個。在這裡，我們將考慮最基本的。

該類Integer有兩個字段，包含該類型的最大和最小可能值int：

場地	描述
`Integer.MAX_VALUE`	`int`類型的最大可能值
`Integer.MIN_VALUE`	`int`類型的最小可能值

有時您希望將可能的最小值或最大值分配int給變量。為避免使用難以理解的常量使您的代碼混亂，您可以將其寫得非常清楚，如下所示：

代碼	描述
`int min = Integer.MIN_VALUE;`	`min == 0x80000000`

該類Integer還有一些有趣的方法。他們來了：

方法	描述
`String Integer.toHexString(int)`	返回一個字符串，它是數字的十六進製表示
`String Integer.toBinaryString(int)`	返回一個字符串，它是數字的二進製表示
`String Integer.toOctalString(int)`	返回一個字符串，它是數字的八進製表示
`Integer Integer.valueOf(int i)`	包裝傳入`int`的`Integer`對象
`Integer Integer.parseInt(String)`	返回從傳遞的字符串中獲得的數字

您之前遇到過靜態Integer.parseInt()方法。讓我們回顧一下它是如何工作的：

int name = Integer.parseInt(string);

如果將包含數字（僅數字）的字符串傳遞給該parseInt()方法，它將解析該字符串並返回它包含的數字。

其餘的方法也很有用。例如，其中一些可以將傳遞的數字轉換為包含該數字的二進制、八進製或十六進製表示形式的字符串。

2.`Double`類

通常，該類Double與類相似Integer，只是它包裝了一個double而不是一個int. 它還具有我們會感興趣的字段和方法。考慮其中的一些：

該Double課程有六個有趣的領域：

場地	描述
`double Double.NEGATIVE_INFINITY`	負無窮大
`double Double.POSITIVE_INFINITY`	正無窮大
`int Double.MIN_EXPONENT`	最小可能指數 (2 ^x )
`int Double.MAX_EXPONENT`	最大可能指數 (2 ^x )
`double Double.MIN_VALUE`	`double`類型的最小可能值
`double Double.MAX_VALUE`	`double`類型的最大可能值

無窮

如果你除以-1.0，0.0你會得到負無窮大。如果除以1.0，0.0您將得到正無窮大。您不僅可以將 a 除以double零，還可以使用它來存儲這些操作的結果。

的指數double

理解指數很容易。在內部，雙精度數由尾數和指數組成。但是這裡指數的值不是，而是。因此，如果指數增加，則數字的總值將增加一倍。10^x2^x1

MIN_EXPONENT == -1024, 這意味著, 這大約等於2^-102410^-308

當然，這個Double類有一些有趣的方法：

方法	描述
`String Double.toHexString(double)`	返回一個字符串，它是數字的十六進製表示
`boolean Double.isInfinite(double)`	檢查傳遞的數字是否為無窮大。
`boolean Double.isNaN(double)`	檢查傳遞的號碼是否為`NaN`
`Double Double.valueOf(double)`	包裝傳入的`double`對象`Double`
`Double Double.parseDouble(String)`	返回從傳遞的字符串中獲得的數字

有趣的是，如果傳遞的數字是正無窮大或負無窮大，有一種isInfinite()方法會返回。true

該isNaN()方法類似——它檢查傳遞的數字是否為NaN（Not-a-Number，一個表示未定義值的特殊常量）。

3.`Character`類

這個Character類之所以有趣，主要是因為它有大量的靜態實用方法，可以讓您檢查字符是否屬於不同的類別。

例子

方法	描述
`Character.isAlphabetic(int)`	檢查字符是否為字母字符
`Character.isLetter(char)`	檢查字符是否為字母
`Character.isDigit(char)`	檢查字符是否為數字
`Character.isSpaceChar(char)`	檢查字符是否為空格、換行符或分頁符（代碼：12、13、14）
`Character.isWhitespace(char)`	檢查字符是否為空白：空格、製表符等。
`Character.isLowerCase(char)`	檢查字符是否為小寫
`Character.isUpperCase(char)`	檢查字符是否為大寫

`Character.toLowerCase(char)`	將字符轉換為小寫
`Character.toUpperCase(char)`	將字符轉換為大寫

這些方法的一個特點是它們適用於所有已知的字母表：阿拉伯數字被歸類為數字等。

4.`Boolean`類

類型Boolean實際上與類型相同boolean。差異很小。

下面我們展示了該類的簡化版本Boolean：

代碼描述

class Boolean
{
   public static final Boolean TRUE = new Boolean(true);
   public static final Boolean FALSE = new Boolean(false);

   private final boolean value;

   public Boolean(boolean value)
   {
      this.value = value;
   }

   public boolean booleanValue()
   {
      return value;
   }

   public static Boolean valueOf(boolean value)
   {
      return (value ? TRUE : FALSE);
   }
}

常量：TRUEè FALSE

Variable

Booleanclass constructor

方法返回內部變量的值

This static method 轉換true為TRUE和falseto FALSE。

該Boolean類型有兩個常量（兩個字段）：

類的常量	對應布爾類型	描述
`Boolean.TRUE`	`true`	真的
`Boolean.FALSE`	`false`	錯誤的

您可以像使用類型一樣使用它們boolean：

代碼	筆記
`if (Boolean.TRUE) { }`	該類`Boolean`是唯一可以在條件內編寫的類
`Boolean a = Boolean.TRUE; boolean b = Boolean.TRUE; boolean c = true;`	所有三個變量都等於`true`/`TRUE`
`Boolean a = Boolean.TRUE; Boolean b = Boolean.TRUE; if (a == b)`	可以同時使用`equals`和比較常量`==` 這也可以。

自動裝箱在這裡效果很好。這意味著您可以像使用類型一樣使用此類型boolean——沒有需要注意的陷阱。

它是如何寫的怎麼運行的

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

Boolean a = Boolean.valueOf(true);
Boolean b = Boolean.valueOf(true);
Boolean c = Boolean.valueOf(false);
boolean d = a.booleanValue();

boolean這裡是和類型的比較Boolean：

boolean a = true;
Boolean b = true; // b will be equal to Boolean.TRUE
Boolean c = true; // c will be equal to Boolean.TRUE

a == b; // true (compared by value)
a == c; // true (compared by value)
b == c; // true (compared by reference, but they point to the same object)

如果你真的需要一個獨立的Boolean對象，那麼你需要顯式地創建它：

boolean a = true;
Boolean b = new Boolean(true); // New Boolean object
Boolean c = true; // c will be equal to Boolean.TRUE

a == b; // true (compared by value)
a == c; // true (compared by value)
b == c; // false (compared by reference, and they point to different objects)

再舉一個例子，我們將使用Booleanan 的內部if：

代碼	筆記
`Boolean less = (2 < 3); if (less) { ... }`	這將編譯和工作

這將編譯，但它不會工作！

代碼	筆記
`Boolean less = null; if (less) { ... }`	錯誤。這一行會拋出異常

5. 自動裝箱時緩存值

有一些與整數包裝器類型相關的陷阱。

如您所知，如果我們比較 anint和 an Integer， theInteger將轉換為 an int：

它是如何寫的	怎麼運行的
`int a = 5; Integer b = 5; if (a == b) { ... }`	`int a = 5; Integer b = Integer.valueOf(5); if (a == b.intValue()) { ... }`

如果將兩個Integer對象相互比較，它們不會轉換為ints：

代碼	控制台輸出
`Integer a = 500; Integer b = 500; int c = 500; System.out.println(a == b); // Compared by reference System.out.println(a == c); System.out.println(b == c);`	`false true true`

a == cand , but ，因為當我們比較and時，我們是在比較引用。這基本上是我們所期望的。b == ca != bab

驚喜

但是如果我們替換500為100，那麼我們會得到完全不同的結果：

代碼	控制台輸出
`Integer a = 100; Integer b = 100; int c = 100; System.out.println(a == b); // Compared by reference System.out.println(a == c); System.out.println(b == c);`	`true true true`

這裡的問題是在自動裝箱期間並不總是實際創建新Integer對象。-128通過inclusive緩存對象的值127。

該類Integer有一個存儲對象的隱藏數組：Integer(-128), Integer(-127), ... Integer(126),Integer(127)

如果你寫Integer x = 128，那麼自動裝箱過程會創建一個新對象，但如果你寫Integer x = 127，那麼自動裝箱過程會從緩存（從數組）中檢索現有對象。

如果您不希望該Integer對象來自緩存，則必須通過以下方式顯式創建它：Integer x = new Integer(127);

所有包裝器類型都有這樣的緩存：Integer, Long, Byte, Short, Boolean。對於Boolean類型來說，它TRUE和FALSE值都是常量，所以本質上也是緩存的。

詳細包裝器類

1.Integer類

2.Double類

3.Character類

4.Boolean類

5. 自動裝箱時緩存值

1.`Integer`類

2.`Double`類

3.`Character`類

4.`Boolean`類