java基本數據類型及其所對應對象的自動裝箱，new,valueof操作研究

昨天，今天從源程序級別仔細觀察了下這些操作的邏輯，除了沒看到過的，

都看過了：）哈哈。。。

jdk從1.5開始有了自動拆箱裝箱功能，

對寫程序方便了不少，1.5開始加了不少新特性麼。

java的基本數據類型有

boolean char byte short int float long double

對應的對象爲

Boolean Character Byte Short Integer Float Long Double

爲了提高效率（不知到底能提高多少）

java在特定的數據類型對象中(Character Byte,Short,Integer,Long)，

對-128-127這個範圍內的整形對象進行了緩存，

以Integer爲例：

有static 內部類

private static class IntegerCache { private IntegerCache(){} static final Integer cache[] = new Integer[-(-128) + 127 + 1]; static { for(int i = 0; i < cache.length; i++) cache[i] = new Integer(i - 128); } }

來緩存這些對象,

另外，valueOf方法中的實現是這樣的：

public static Integer valueOf(int i) { final int offset = 128; if (i >= -128 && i <= 127) { // must cache return IntegerCache.cache[i + offset]; } return new Integer(i); }

所以在-128-127之間進行valueof操作，

得到的都是同一個對象。

另外，Boolean對象的緩存爲

/** * The <code>Boolean</code> object corresponding to the primitive * value <code>true</code>. */ public static final Boolean TRUE = new Boolean(true); /** * The <code>Boolean</code> object corresponding to the primitive * value <code>false</code>. */ public static final Boolean FALSE = new Boolean(false);

Boolean.valueOf操作的邏輯如下：

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

也是緩存的結果。

下面是自動裝箱，由編譯器完成。

自動裝箱的效果類似於valueOf的效果，就是對-128-127之間的自動裝箱，

得到的必然是同一個對象。

而new操作就不一樣了，

new操作對這些數據類型來說，必然是建立一個新的對象，不會與以前new操作建立的對象重複。

閒話少說，上測試代碼：

public void compare() throws Exception { Boolean autoboxing_boolean_true_1 = true; Boolean autoboxing_boolean_true_2 = true; System.out.println("自動對true進行裝箱操作得到的兩個Boolean是否是同一個對象"); System.out.println(autoboxing_boolean_true_1 == autoboxing_boolean_true_2); Boolean new_boolean_true_1 = new Boolean(true); Boolean new_boolean_true_2 = new Boolean(true); System.out.println("自動對true進行new操作得到的兩個Boolean是否是同一個對象"); System.out.println(new_boolean_true_1 == new_boolean_true_2); Boolean valueof_boolean_true_1 = Boolean.valueOf(true); Boolean valueof_boolean_true_2 = Boolean.valueOf(true); System.out.println("自動對true進行valueof操作得到的兩個Boolean是否是同一個對象"); System.out.println(valueof_boolean_true_1 == valueof_boolean_true_1); final int min = 28; final int max = 333; Character autoboxing_character_min_1 = min; Character autoboxing_character_min_2 = min; System.out.println("自動對"+min+"進行裝箱操作得到的兩個Character是否是同一個對象"); System.out.println(autoboxing_character_min_1 == autoboxing_character_min_2); Character autoboxing_character_max_1 = max; Character autoboxing_character_max_2 = max; System.out.println("自動對"+max+"進行裝箱操作得到的兩個Character是否是同一個對象"); System.out.println(autoboxing_character_max_1 == autoboxing_character_max_2); Character new_character_min_1 = new Character((char)min); Character new_character_min_2 = new Character((char)min); System.out.println("自動對"+min+"進行new操作得到的兩個Character是否是同一個對象"); System.out.println(new_character_min_1 == new_character_min_2); Character new_character_max_1 = new Character((char)max); Character new_character_max_2 = new Character((char)max); System.out.println("自動對"+max+"進行new操作得到的兩個Character是否是同一個對象"); System.out.println(new_character_max_1 == new_character_max_2); Character valueof_character_min_1 = Character.valueOf((char)min); Character valueof_character_min_2 = Character.valueOf((char)min); System.out.println("自動對"+min+"進行valueof操作得到的兩個Character是否是同一個對象"); System.out.println(valueof_character_min_1 == valueof_character_min_2); Character valueof_character_max_1 = Character.valueOf((char)max); Character valueof_character_max_2 = Character.valueOf((char)max); System.out.println("自動對"+max+"進行valueof操作得到的兩個Character是否是同一個對象"); System.out.println(valueof_character_max_1 == valueof_character_max_2); Byte autoboxing_byte_min_1 = min; Byte autoboxing_byte_min_2 = min; System.out.println("自動對"+min+"進行裝箱操作得到的兩個Byte是否是同一個對象"); System.out.println(autoboxing_byte_min_1 == autoboxing_byte_min_2); Byte autoboxing_byte_max_1 = (byte)max; Byte autoboxing_byte_max_2 = (byte)max; System.out.println("自動對"+max+"進行裝箱操作得到的兩個Byte是否是同一個對象"); System.out.println(autoboxing_byte_max_1 == autoboxing_byte_max_2); Byte new_byte_min_1 = new Byte((byte)min); Byte new_byte_min_2 = new Byte((byte)min); System.out.println("自動對"+min+"進行new操作得到的兩個Byte是否是同一個對象"); System.out.println(new_byte_min_1 == new_byte_min_2); Byte new_byte_max_1 = new Byte((byte)max); Byte new_byte_max_2 = new Byte((byte)max); System.out.println("自動對"+max+"進行new操作得到的兩個Byte是否是同一個對象"); System.out.println(new_byte_max_1 == new_byte_max_2); Byte valueof_byte_min_1 = Byte.valueOf((byte)min); Byte valueof_byte_min_2 = Byte.valueOf((byte)min); System.out.println("自動對"+min+"進行valueof操作得到的兩個Byte是否是同一個對象"); System.out.println(valueof_byte_min_1 == valueof_byte_min_2); Byte valueof_byte_max_1 = Byte.valueOf((byte)max); Byte valueof_byte_max_2 = Byte.valueOf((byte)max); System.out.println("自動對"+max+"進行valueof操作得到的兩個Byte是否是同一個對象"); System.out.println(valueof_byte_max_1 == valueof_byte_max_2); Short autoboxing_short_min_1 = min; Short autoboxing_short_min_2 = min; System.out.println("自動對"+min+"進行裝箱操作得到的兩個Short是否是同一個對象"); System.out.println(autoboxing_short_min_1 == autoboxing_short_min_2); Short autoboxing_short_max_1 = max; Short autoboxing_short_max_2 = max; System.out.println("自動對"+max+"進行裝箱操作得到的兩個Short是否是同一個對象"); System.out.println(autoboxing_short_max_1 == autoboxing_short_max_2); Short new_short_min_1 = new Short((short)min); Short new_short_min_2 = new Short((short)min); System.out.println("自動對"+min+"進行new操作得到的兩個Short是否是同一個對象"); System.out.println(new_short_min_1 == new_short_min_2); Short new_short_max_1 = new Short((short)max); Short new_short_max_2 = new Short((short)max); System.out.println("自動對"+max+"進行new操作得到的兩個Short是否是同一個對象"); System.out.println(new_short_max_1 == new_short_max_2); Short valueof_short_min_1 = Short.valueOf((short)min); Short valueof_short_min_2 = Short.valueOf((short)min); System.out.println("自動對"+min+"進行valueof操作得到的兩個Short是否是同一個對象"); System.out.println(valueof_short_min_1 == valueof_short_min_2); Short valueof_short_max_1 = Short.valueOf((short)max); Short valueof_short_max_2 = Short.valueOf((short)max); System.out.println("自動對"+max+"進行valueof操作得到的兩個Short是否是同一個對象"); System.out.println(valueof_short_max_1 == valueof_short_max_2); Integer autoboxing_integer_min_1 = min; Integer autoboxing_integer_min_2 = min; System.out.println("自動對"+min+"進行裝箱操作得到的兩個Integer是否是同一個對象"); System.out.println(autoboxing_integer_min_1 == autoboxing_integer_min_2); Integer autoboxing_integer_max_1 = max; Integer autoboxing_integer_max_2 = max; System.out.println("自動對"+max+"進行裝箱操作得到的兩個Integer是否是同一個對象"); System.out.println(autoboxing_integer_max_1 == autoboxing_integer_max_2); Integer new_integer_min_1 = new Integer(min); Integer new_integer_min_2 = new Integer(min); System.out.println("自動對"+min+"進行new操作得到的兩個Integer是否是同一個對象"); System.out.println(new_integer_min_1 == new_integer_min_2); Integer new_integer_max_1 = new Integer(max); Integer new_integer_max_2 = new Integer(max); System.out.println("自動對"+max+"進行new操作得到的兩個Integer是否是同一個對象"); System.out.println(new_integer_max_1 == new_integer_max_2); Integer valueof_integer_min_1 = Integer.valueOf(min); Integer valueof_integer_min_2 = Integer.valueOf(min); System.out.println("自動對"+min+"進行valueof操作得到的兩個Integer是否是同一個對象"); System.out.println(valueof_integer_min_1 == valueof_integer_min_2); Integer valueof_integer_max_1 = Integer.valueOf(max); Integer valueof_integer_max_2 = Integer.valueOf(max); System.out.println("自動對"+max+"進行valueof操作得到的兩個Integer是否是同一個對象"); System.out.println(valueof_integer_max_1 == valueof_integer_max_2); Float autoboxing_float_min_1 = (float)min; Float autoboxing_float_min_2 = (float)min; System.out.println("自動對"+min+"進行裝箱操作得到的兩個Float是否是同一個對象"); System.out.println(autoboxing_float_min_1 == autoboxing_float_min_2); Float autoboxing_float_max_1 = (float)max; Float autoboxing_float_max_2 = (float)max; System.out.println("自動對"+max+"進行裝箱操作得到的兩個Float是否是同一個對象"); System.out.println(autoboxing_float_max_1 == autoboxing_float_max_2); Float new_float_min_1 = new Float(min); Float new_float_min_2 = new Float(min); System.out.println("自動對"+min+"進行new操作得到的兩個Float是否是同一個對象"); System.out.println(new_float_min_1 == new_float_min_2); Float new_float_max_1 = new Float(max); Float new_float_max_2 = new Float(max); System.out.println("自動對"+max+"進行new操作得到的兩個Float是否是同一個對象"); System.out.println(new_float_max_1 == new_float_max_2); Float valueof_float_min_1 = Float.valueOf(min); Float valueof_float_min_2 = Float.valueOf(min); System.out.println("自動對"+min+"進行valueof操作得到的兩個Float是否是同一個對象"); System.out.println(valueof_float_min_1 == valueof_float_min_2); Float valueof_float_max_1 = Float.valueOf(max); Float valueof_float_max_2 = Float.valueOf(max); System.out.println("自動對"+max+"進行valueof操作得到的兩個Float是否是同一個對象"); System.out.println(valueof_float_max_1 == valueof_float_max_2); Long autoboxing_long_min_1 = (long)min; Long autoboxing_long_min_2 = (long)min; System.out.println("自動對"+min+"進行裝箱操作得到的兩個Long是否是同一個對象"); System.out.println(autoboxing_long_min_1 == autoboxing_long_min_2); Long autoboxing_long_max_1 = (long)max; Long autoboxing_long_max_2 = (long)max; System.out.println("自動對"+max+"進行裝箱操作得到的兩個Long是否是同一個對象"); System.out.println(autoboxing_long_max_1 == autoboxing_long_max_2); Long new_long_min_1 = new Long(min); Long new_long_min_2 = new Long(min); System.out.println("自動對"+min+"進行new操作得到的兩個Long是否是同一個對象"); System.out.println(new_long_min_1 == new_long_min_2); Long new_long_max_1 = new Long(max); Long new_long_max_2 = new Long(max); System.out.println("自動對"+max+"進行new操作得到的兩個Long是否是同一個對象"); System.out.println(new_long_max_1 == new_long_max_2); Long valueof_long_min_1 = Long.valueOf(min); Long valueof_long_min_2 = Long.valueOf(min); System.out.println("自動對"+min+"進行valueof操作得到的兩個Long是否是同一個對象"); System.out.println(valueof_long_min_1 == valueof_long_min_2); Long valueof_long_max_1 = Long.valueOf(max); Long valueof_long_max_2 = Long.valueOf(max); System.out.println("自動對"+max+"進行valueof操作得到的兩個Long是否是同一個對象"); System.out.println(valueof_long_max_1 == valueof_long_max_2); Double autoboxing_double_min_1 = (double)min; Double autoboxing_double_min_2 = (double)min; System.out.println("自動對"+min+"進行裝箱操作得到的兩個Double是否是同一個對象"); System.out.println(autoboxing_double_min_1 == autoboxing_double_min_2); Double autoboxing_double_max_1 = (double)max; Double autoboxing_double_max_2 = (double)max; System.out.println("自動對"+max+"進行裝箱操作得到的兩個Double是否是同一個對象"); System.out.println(autoboxing_double_max_1 == autoboxing_double_max_2); Double new_double_min_1 = new Double(min); Double new_double_min_2 = new Double(min); System.out.println("自動對"+min+"進行new操作得到的兩個Double是否是同一個對象"); System.out.println(new_double_min_1 == new_double_min_2); Double new_double_max_1 = new Double(max); Double new_double_max_2 = new Double(max); System.out.println("自動對"+max+"進行new操作得到的兩個Double是否是同一個對象"); System.out.println(new_double_max_1 == new_double_max_2); Double valueof_double_min_1 = Double.valueOf(min); Double valueof_double_min_2 = Double.valueOf(min); System.out.println("自動對"+min+"進行valueof操作得到的兩個Double是否是同一個對象"); System.out.println(valueof_double_min_1 == valueof_double_min_2); Double valueof_double_max_1 = Double.valueOf(max); Double valueof_double_max_2 = Double.valueOf(max); System.out.println("自動對"+max+"進行valueof操作得到的兩個Double是否是同一個對象"); System.out.println(valueof_double_max_1 == valueof_double_max_2); }

輸出結果如下：

自動對true進行裝箱操作得到的兩個Boolean是否是同一個對象
true
自動對true進行new操作得到的兩個Boolean是否是同一個對象
false
自動對true進行valueof操作得到的兩個Boolean是否是同一個對象
true
自動對28進行裝箱操作得到的兩個Character是否是同一個對象
true
自動對333進行裝箱操作得到的兩個Character是否是同一個對象
false
自動對28進行new操作得到的兩個Character是否是同一個對象
false
自動對333進行new操作得到的兩個Character是否是同一個對象
false
自動對28進行valueof操作得到的兩個Character是否是同一個對象
true
自動對333進行valueof操作得到的兩個Character是否是同一個對象
false
自動對28進行裝箱操作得到的兩個Byte是否是同一個對象
true
自動對333進行裝箱操作得到的兩個Byte是否是同一個對象
true
自動對28進行new操作得到的兩個Byte是否是同一個對象
false
自動對333進行new操作得到的兩個Byte是否是同一個對象
false
自動對28進行valueof操作得到的兩個Byte是否是同一個對象
true
自動對333進行valueof操作得到的兩個Byte是否是同一個對象
true
自動對28進行裝箱操作得到的兩個Short是否是同一個對象
true
自動對333進行裝箱操作得到的兩個Short是否是同一個對象
false
自動對28進行new操作得到的兩個Short是否是同一個對象
false
自動對333進行new操作得到的兩個Short是否是同一個對象
false
自動對28進行valueof操作得到的兩個Short是否是同一個對象
true
自動對333進行valueof操作得到的兩個Short是否是同一個對象
false
自動對28進行裝箱操作得到的兩個Integer是否是同一個對象
true
自動對333進行裝箱操作得到的兩個Integer是否是同一個對象
false
自動對28進行new操作得到的兩個Integer是否是同一個對象
false
自動對333進行new操作得到的兩個Integer是否是同一個對象
false
自動對28進行valueof操作得到的兩個Integer是否是同一個對象
true
自動對333進行valueof操作得到的兩個Integer是否是同一個對象
false
自動對28進行裝箱操作得到的兩個Float是否是同一個對象
false
自動對333進行裝箱操作得到的兩個Float是否是同一個對象
false
自動對28進行new操作得到的兩個Float是否是同一個對象
false
自動對333進行new操作得到的兩個Float是否是同一個對象
false
自動對28進行valueof操作得到的兩個Float是否是同一個對象
false
自動對333進行valueof操作得到的兩個Float是否是同一個對象
false
自動對28進行裝箱操作得到的兩個Long是否是同一個對象
true
自動對333進行裝箱操作得到的兩個Long是否是同一個對象
false
自動對28進行new操作得到的兩個Long是否是同一個對象
false
自動對333進行new操作得到的兩個Long是否是同一個對象
false
自動對28進行valueof操作得到的兩個Long是否是同一個對象
true
自動對333進行valueof操作得到的兩個Long是否是同一個對象
false
自動對28進行裝箱操作得到的兩個Double是否是同一個對象
false
自動對333進行裝箱操作得到的兩個Double是否是同一個對象
false
自動對28進行new操作得到的兩個Double是否是同一個對象
false
自動對333進行new操作得到的兩個Double是否是同一個對象
false
自動對28進行valueof操作得到的兩個Double是否是同一個對象
false
自動對333進行valueof操作得到的兩個Double是否是同一個對象
false

對結果的簡要說明：

new操作在任何時候都是同一個對象

對float double進行valueof操作都是不同的對象

byte由於強制類型轉換，其範圍本來就是-128-127故自動裝箱，valueof操作都是同一個對象

其他的對28進行自動裝箱，valueof是同一個對象

對333則不是