課堂
開始
開始學習
CodeGym /Adesua ahorow /All lectures for TW purposes /詳細包裝器類

詳細包裝器類

All lectures for TW purposes
等級 1 , 課堂 1120
開放

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

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

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值都是常量，所以本質上也是緩存的。

留言
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION