簡單包裝器類

在 java.lang 包中有很多類，其中一些類和前面學過的基本數據類型有關，叫做包裝器類（Wrapper)。
java 使用簡單的數據類型，例如整型（int ) 和字符型 （char )。這些數據類型不是對象層次結構的組成部分。他們通過值傳遞給方法而不能直接通過引用傳遞。 有時需要對這些簡單的類型建立對象表達式，例如，當把數據放到集合中時，需要包裝成對象。爲了能夠用對象的形式代表簡單數據類型， java提供了與 每一個 簡單類型相應的類。從本質上講，這些類中包裝了(Wrap)簡單類型的數據。因此，它們通常被稱作類型包裝器或者包裝類。

Number

抽象類 Number 定義了一個數字包裝器類型的超類。
字節型（byte)、短整型（short) 、整型（int）、長整型（long)、浮點型（float) 和 雙精度（double) 等簡單基本類型的包裝器都是它的子類。
Number 有返回不同數字格式的值的抽象方法。例如 doubleValue() 方法從包裝器類返回雙精度（double)值， floatValue() 方法返回浮點（float) 值等。

Number 中定義的方法

方法	描述
byte byteValue()	返回包裝器對象中的值(字節型）
short shortValue()	返回包裝器對象中的值(短整型）
int intValue()	返回包裝器對象中的值(整型）
long longValue()	返回包裝器對象中的值(長整型）
float floatValue()	返回包裝器對象中的值(浮點型）
double doubleValue()	返回包裝器對象中的值(雙精度）

Number 有 6個具體的子類，包含了 6種類型的顯示值：字節型（byte)、短整型（short) 、整型（int）、長整型（long)、浮點型（float) 和 雙精度（double) 。這些類都實現了 Compareable接口，可以比較包裝器對象的大小。

Byte 、Short、Integer、Long

Byte 、Short、Integer、Long 類分別是 字節型（byte)、短整型（short) 、整型（int）、長整型（long) 整數類型的包裝器。它們的構造函數如下：

Byte( byte value) ;  Byte( String str)
Short(short value); Short(String str)
Integer(int value); Integer(String str)
Long(long value);   Long(String str)

正如所看到的，這些對象可以由數值或表示有效整數值得字符串創建。
由這些類定義一些方法以便從字符串解析整數和將字符串轉換爲整數。爲了方便起見，這些方法提供的變量可以用來指定 radix,也稱爲基數。如通常 二進制（Binary)的基數是2.
在這些類中定義了兩個常量：MAX_VALUE 和 MIN_VALUE,分別表示每種數據類型表示的最大值和最小值。

這些類中定義了幾種類型的方法。

1）基本類型到包裝器類型的轉換。

static Byte valueOf(byte b)
static Short valueOf(short i)
static Integer valueOf(int i)
static Long valueOf(short i)

2)包裝器類型到基本類型的轉換

byteValue()
shortValue()
intValue()
longValue()

3) 字符串到數字類型轉換

parseByte()
parseShort()
parseInt()
parseLong()

4)數字類型到字符串的轉換
包裝器 類 Integer 中定義了下面的方法：

static String toString(int i, int radix)    //按照 radix 進制把整數 i轉換成字符串，轉換結果含符號字符。
static String toBinaryString( int value)    //按照二進制轉換成字符串（補碼方式），轉換結果不含符號字符，即最高位爲1表示負數。
static String toOctalString(int value)      //按照八進制轉換成字符串，轉換結果不含符號字符。
static String toHexString(int Value)        //按照十六進制轉換成字符串，轉換結果不含符號字符。

Byte 、Short、Long 中都有對應的方法，只是方法的參數類型爲對應的簡單類型。

5）包裝器類型到字符串的轉換

String toString()

6)字符串到包裝器類型的轉換

static Integer ValueOf(String s, int radix)     //按照 radix 進制把字符串 s 轉換成 Integer類型。

Byte 、Short、Long 中都有對應的方法

數字和字符串轉換

String s1 = "12";
String s2 = "34";
String s = null;
int i1 = 0,i2 = 0, sum = 0;
i1 = Integer.parseInt(s1);
i2 = new Integer(s2).intValue();

sum = i1 +i2;
s = Integer.toString(sum);
System.out.println(s);  //46

用不同進制把數字和字符串轉換

int i = -34567;
String s = null;
System.out.println("二進制字符串："+Integer.toBinaryString(i));
System.out.println("八制字符串："+Integer.toOctalString(i));
System.out.println("十六制字符串："+Integer.toHexString(i));
s = Integer.toString(i,8);
System.out.println("帶符號，八進制字符串："+ s);
Integer I = Integer.valueOf(s,8);
System.out.println("Integer對象的值："+I.intValue());

// 二進制字符串：11111111111111110111100011111001
// 八制字符串：37777674371
// 十六制字符串：ffff78f9
// 帶符號，八進制字符串：-103407
// Integer對象的值：-34567

Float 和 Double

雙精度（Double) 和 浮點 (Float) 分別是對類型 double 和類型 float 的浮點值得包裝器。
浮點（Float)的構造函數如下所示：

Float(double value)
Float(float value)
Float(String s)

浮點 對象可以由 類型 float,或 類型 double的值創建。它們也能由浮點的字符串表達式創建。

雙精度構造函數如下：

Double (double value)
Double(String s)

雙精度對象可以被雙精度值或浮點值的字符串創建。

浮點和雙精度都定義瞭如下常量

常量	描述
MAX_VALUE	最大值值
MIN_VALUE	最小正值
POSITIVE_INFINITY	正無窮
NEGATIVE_INFINITY	負無窮
NaN	非數字

Float類中定義的方法

方法	描述
int compareTo(Float f)	將調用 對象的數值與參數 f 中的數值進行比較，如果兩者相等，則返回0；如果調用對象的值小於f的值，則返回負值；如果調用對象的值大於f的值，則返回正值
static float parseFloat(String s)throws NumberFormatException	以 10 位基數，把字符串 s 解析成浮點數。s 中的字符應該是有效的數字字符。
static String toString(float value)	把一個浮點轉換成字符串
static Float valueOf(String s)throws NumberFormatException	把字符串 s 轉化成 Float 對象。s 中的字符應該是有效的數字字符。

Double 類中定義的方法

方法	描述
int compareTo(Double d)	將調用 對象的數值與參數 f 中的數值進行比較，如果兩者相等，則返回0；如果調用對象的值小於f的值，則返回負值；如果調用對象的值大於f的值，則返回正值
static double parseDouble(String s)throws NumberFormatException	以 10 位基數，把字符串 s 解析成雙精度。s 中的字符應該是有效的數字字符。
static String toString(double value)	把一個雙精度轉換成字符串
static Double valueOf(String s)throws NumberFormatException	把字符串 s 轉化成 Double 對象。s 中的字符應該是有效的數字字符。

Character

Character 是針對字符型 （char）的一個簡單的包裝器。
其構造函數如下：

Character(char ch)

這裏 ch 指定了被創建的 Character 對象所包裝的字符。
調用如下的 charValue()方法可以獲得包含在 Character 對象中的字符型（char）值。
Character 類定義了很多常數和靜態方法

方法	描述
static boolean isDefined(char ch)	如果 ch 是由 Unicode定義的，則返回true,否則返回 false
static boolean isDigit(char ch)	如果 ch 是一個數字，則返回 true,否則返回 false
static boolean isIdentifierIgnorable(char ch)	如果在一個標識符中ch應被忽略，則返回true,否則返回false
static boolean isJavaIdentifierPart(char ch)	如果 ch 可以被作爲 java標識符的一部分（除了第一個字符），則返回true,否則返回 false
static boolean isJavaIdentifierStart(char ch)	如果 ch 可以被作爲 java標識符的首字符，則返回true,否則返回 false
static boolean isLetter(char ch)	如果 ch 是一個字母，則返回 true,否則返回 false
static Boolean isLetterOrDigit(char ch)	如果 ch 是一個字母或一個數字，則返回 true,否則返回 false
static boolean isLowerCase(char ch)	當 ch 是小寫字母時，返回 true,否則返回 false
static boolean isSpaceChar(char ch)	如果 ch 是Unicode編碼的空格字符，則返回true,否則返回 false
static boolean isTitleCase(char ch)	如果 ch 是 Unicode編碼的標題字符，則返回true,否則返回false
static boolean isUpperCase(char ch)	如果 ch 是一個大寫字母，則返回 true,否則返回 false
static boolean isWhitespace(char ch)	如果 ch 是一個空白符，則返回 true,否則返回 false
static char toLowerCase(char ch)	返回 ch 的小寫等價形式
static char toTitleCase(char ch)	返回 ch 的標題等價形式
static char toUpperCase(char ch)	返回 ch 的大寫等價形式
static String toString(char ch)	把字符轉化成字符串

Boolean

Boolean 是一個針對布爾（boolean）值得非常細小的包裝器，主要用在通過引用傳遞布爾（boolean）變量的場合。它包含了常數 true和 false ，這些常數定義了Boolean 對象的真與假。Boolean 也定義了 type 域，它是 boolean 的 Class對象。在 Boolean 中定義瞭如下的構造函數

Boolean(boolean boolValue)
Boolean(String boolString)

在第一種形式中，boolValue 要麼是 true,要麼是 false。在第二種形式中 如果在
boolString 中包含了字符串 “true”(不論是大寫形式還是小寫形式），則新的Boolean對象將爲真；否則爲假。
Boolean定義如下方法

方法	描述
boolean booleanValue()	返回調用對象的 boolean 值
boolean equals(Object obj)	如果調用對象與 obj 相等則返回 true,否則返回 false
int hashCode	返回調用對象的散列值
static Boolean valueOf(String str)	把字符串 str 轉化爲Boolean對象

String s ="true";
boolean b =true;
if(b==new Boolean(s).booleanValue()){
   System.out.println("兩個布爾變量相等");
}
System.out.println(Boolean.valueOf(s).hashCode());
//兩個布爾變量相等
//1231

自動裝箱與拆箱

自 JDK 5.0 開始，基本類型的變量能夠自動轉換爲它的包裝器類型的對象，這種自動轉換被稱爲 自動裝箱。 包裝器對象就像 ‘箱子’ 一樣，其中存放着相應的基本類型的值。其反向轉換，即自動把包裝器類的對象轉換爲基本類型的值，被稱爲 自動拆箱。

自動裝箱：

 Integer objval = 9;

語句自動把 int 型的 9 裝箱轉換爲 Integer 對象。objVal引用一個Integer對象，對象中的值爲 9 。等價於：

 Integer objVal = new Integer(9);

自動拆箱

int i = objVal;

自動拆箱 轉換自動提取包裝器對象中的基本類型值。objVal引用一個Integer對象，i 的值爲 9 。等價於：

int i = objVal.intValue();

自動裝箱 與 自動拆箱 轉換在許多上下文環境中會被應用，例如在賦值 和傳遞引用的時候。類集合中只能存放對象，不能存放基本類型的值，當把基本類型的值放入集合時，就會發生自動裝箱轉換，把基本類型值轉換爲對應的包裝器對象。

這種自動轉換不是在任何時候都能進行的，特別是不能像處理對象那樣直接使用基本類型的變量或值得引用。例如：給定一個 int 型變量，表達式 i.toString()是不能通過編譯的，但是可以對其先進行強制轉換來解決問題:
((Object)j).toString();
裝箱轉換可能需要一個包裝器類的對象，這將小號內存。由於包裝器對象中的值是不可變的。所以擁有相同的值得對象是可以互相使用的，因此，實際上不需要創建有用相同值的兩個不同的包裝器類的對象。Java對於某些類型，在某些值域範圍內相同值的裝箱總是產生相同的對象。