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则不是