java对象的包装,java基本数据类型对象包装类

java基本数据类型对象包装类

一、包装类说明

为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类。

基本数据类型与相应的包装类

byte             Byte

short    Short

int         Integer

long             Long

float     Float

double Double

char             Character

boolean      Boolean

二、包装类主要功能

该包装对象主要用基本类型和字符串之间的转换。

(1)基本类型--->字符串

1、基本类型数值+""

2、用String类中的静态方法valueOf(基本类型数值);

3、用包装类的静态方法valueOf(基本类型数值);

(2)字符串--->基本类型

1、使用包装类中的静态方法:xxx parseXxx("xxx类型的字符串");

eg:

int parseInt("intstring");

long parseLong("longstring");

boolean parseBoolean("booleanstring");

备注：只有Character没有parse方法，本身就是封装了字符，无须转换

2、如果字符串被xxx包装类进行对象的封装。

可使用另一个非静态的方法，xxxValue();

将一个xxx包装类对象转成基本数据类型值。

三、JDK1.5自动装箱拆箱

(1)拆箱装箱概念

装箱：自动将基本数据类型转换为包装器类型；

拆箱：自动将包装器类型转换为基本数据类型。

(2)jdk1.5后包装类新特性

Integeri=4;//自动装箱，简化书写：Integer i=new Integer(4);

i=i+6;//i=new Integer(i.intValue+6);//自动拆箱

System.out.println(i.intValue());//10

(3)拆箱装箱实现

装箱：自动将基本数据类型转换为包装器类型；装箱过程是通过调用包装器的valueOf方法实现的

拆箱：自动将包装器类型转换为基本数据类型。拆箱过程是通过调用包装器的xxxValue方法实现的。(xxx代表对应的基本数据类型)。

【1】实现代码案例

package wrapper;

public class Autoboxing_Unboxing {

public static void main(String[] args) {

Integer i = 10;//装箱

int n = i;//拆箱

}

}

【2】反编译代码发现

反编译class文件之后得到如下内容：

从反编译得到的字节码内容可以看出，在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法。

其他的也类似，比如Double、Character，不相信的朋友可以自己手动尝试一下。

【3】结论

因此可以用一句话总结装箱和拆箱的实现过程：

装箱过程是通过调用包装器的valueOf方法实现的，

拆箱过程是通过调用包装器的xxxValue方法实现的。(xxx代表对应的基本数据类型)。

四、包装类装箱之valueOf方法之思

1、创建对象与valueOf方法【装箱】

思考：由于装箱过程是调用包装器的valueOf方法实现的，

即：当Integer i=3过程，创建Integer对象的时候，这样一个装箱过程，就会调用包装器的valueOf方法。所以，我们在此重点讨论这个valueOf方法。

2、valueOf方法结论

主要得出几个结论：

2.1不同包装类之间，有共性的地方。分为三大派别：

【1】Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。比较特殊，根据数值的大小范围而获得对象的方式不同

【2】Double、Float的valueOf方法的实现是类似的，每次都返回不同的对象。

【3】Boolean的valueOf方法实现，每次返回的都是同一个对象

2.2对于类别【1】

(1)有两种创建对象的情况：

《1》在一些特定取值范围内，创建的对象是共享的，即：该数值范围的对象，在内存中只创建一个(一次)，以后想创建该数值的对象，直接获取即可，不需要去new新的。

这个范围的取值情况是：

相同对象范围：在该范围内，同数值情况下，对象是相同的，是同一个。

Integer    相同对象范围  [-128,127]

Short      相同对象范围  [-128,127]

Byte      相同对象范围  [-128,127]

Character  相同对象范围  [0,127]

Long      相同对象范围 [-128,127]

《2》除了上述的取值范围内，对象只创建一个，这里所说的范围内，对象不会共享，相同数值情况下，会创建不同的对象

这个范围的取值情况是：

不同对象范围：在该范围内，同数值情况下，对象是不同的，是多个不同的。

Integer    不同对象范围 i<128||i>=128

Short     不同对象范围 s<128||s>=128

Byte      不同对象范围  无

Character  不同对象范围  c>=128

Long      不同对象范围 L<128||L>=128

综合《1》《2》得

Integer相同对象范围[-128,127]不同对象范围i<128||i>=128

Short相同对象范围[-128,127]不同对象范围s<128||s>=128

Byte相同对象范围[-128,127]不同对象范围无

Character相同对象范围[0,127]不同对象范围c>=128

Long相同对象范围[-128,127]不同对象范围L<128||L>=128

(2)Integer的valueOf源码

来源：博客

博文：Java自动装箱和拆箱

博主：jackiehff

网址：http://blog..net/jackiehff/article/details/8509056

【1】valueOf工厂方法

public static Integer valueOf(int i) {

if(i >= -128 &&i<=IntegerCache.high)

//如果i在-128~high之间,就直接在缓存中取出i的Integer类型对象

return IntegerCache.cache[i + 128];

else

return new Integer(i); //否则就在堆内存中创建

}

【2】IntegerCache内部类

private static class IntegerCache {//内部类，注意它的属性都是定义为static final

static final inthigh; //缓存上界

static final Integer cache[];//cache缓存是一个存放Integer类型的数组

static {//静态语句块

final int low = -128;//缓存下界，值不可变

// high valuemay beconfigured by property

int h = 127;// h值，可以通过设置jdk的AutoBoxCacheMax参数调整(参见(3))

if (integerCacheHighPropValue!=null) {

// UseLong.decode here to avoid invoking methods that

// requireInteger's autoboxing cache to be initialized

// 通过解码integerCacheHighPropValue，而得到一个候选的上界值

int i = Long.decode(integerCacheHighPropValue).intValue();

// 取较大的作为上界，但又不能大于Integer的边界MAX_VALUE

i = Math.max(i, 127);//上界最小为127

// Maximumarray size is Integer.MAX_VALUE

h = Math.min(i, Integer.MAX_VALUE - -low);

}

high = h; //上界确定，此时high默认一般是127

// 创建缓存块，注意缓存数组大小

cache =new Integer[(high - low) +1];

int j = low;

for(int k = 0; k

cache[k] =new Integer(j++);// -128到high值逐一分配到缓存数组

}

private IntegerCache() {}//构造方法,不需要构造什么

}

分析：取值范围[-128,127]共享对象，之外创建独立对象

(3)Short的valueOf源码

public static Short valueOf(short s) {

final int offset = 128;

int sAsInt = s;

if (sAsInt >= -128 &&sAsInt <= 127) { // must cache

return ShortCache.cache[sAsInt +offset];

}

return new Short(s);

}

分析：取值范围[-128,127]共享对象，之外创建独立对象

(4)Long的valueOf源码

public static Long valueOf(long l) {

final int offset = 128;

if (l >= -128 &&l <= 127) { // will cache

return LongCache.cache[(int)l + offset];

}

return new Long(l);

}

分析：取值范围[-128,127]共享对象，之外创建独立对象

(5)Byte的ValueOf源码

public static Byte valueOf(byte b) {

final int offset = 128;

return ByteCache.cache[(int)b +offset];

}

private static class ByteCache {

private ByteCache(){}

static final Byte cache[] =new Byte[-(-128) + 127 + 1];

static {

for(int i = 0; i < cache.length;i++)

cache[i] =new Byte((byte)(i - 128));

}

}

分析：取值范围[-128,127]共享对象

备注：基本数据类型byte的取值范围[-128,127]

(6)Character的valueOf源码

public static Character valueOf(char c) {

if (c <= 127) {//must cache

return CharacterCache.cache[(int)c];

}

return new Character(c);

}

分析：取值范围[0,127]共享对象，之外创建独立对象

(7)一些测试案例

《1》案例一

package wrapper;

public class CharacterTest {

//测试结论： 0-127范围，对象共享；128开始，创建不同的新对象

public static void main(String[] args) {

Character c1=(char) 128;

Character c2=(char)128;

System.out.println(c1==c2);//false

System.out.println(c1.equals(c2));//true

Character c11=(char) 127;

Character c12=(char)127;

System.out.println(c11==c12);//true

System.out.println(c11.equals(c12));//true

Character c21=(char) 0;

Character c22=(char)0;

System.out.println(c21==c22);//true

System.out.println(c21.equals(c22));//true

}

}

《2》案例二

package wrapper;

public class ByteTest {

//测试结论：byte取值的范围：-128-127

//而在byte的范围内的对象都是可以共享的

public static void main(String[] args) {

//byte最大

Byte b1=127;

Byte b2=127;

System.out.println(b1==b2);//true

System.out.println(b1.equals(b2));//true

//byte最小

Byte b11=-128;

Byte b12=-128;

System.out.println(b11==b12);

System.out.println(b11.equals(b12));

//对于超出byte取值范围[-128,127]的，最终都会转为byte范围内的数字，所以一样得到了true的结果

// Byte b12=128;//报错

Byte b13=(byte) 128;

//int(32位)的128强制类型转为byte(8位)型，其中会把多余的24位剔除，从而转换成byte范围的数

Byte b23=(byte) 128;

System.out.println(b13==b23);//true

System.out.println(b13.equals(b23));//true

Byte b21=(byte) -129;

Byte b22=(byte) -129;

System.out.println(b21==b22);//true

System.out.println(b21.equals(b22));//true

}

}

2.3对于类别【2】Double、Float的valueOf方法的实现是类似的，每次都返回不同的对象】

(1)Double 的ValueOf源码

public static Double valueOf(double d) {

returnnew Double(d);

}

分析：每次都创建不同的对象

(2)Float 的ValueOf源码

public static Float valueOf(floatf) {

return new Float(f);

}

分析：每次都创建不同的对象

2.4对于类别【3】Boolean的valueOf方法实现，每次返回的都是同一个对象

Boolean 的ValueOf源码

public static final Boolean TRUE =new Boolean(true);

public static final Boolean FALSE =new Boolean(false);

public static Boolean valueOf(booleanb) {

return (b ?TRUE : FALSE);

}

分析：每次的对象都是同一个，因为那个对象是创建好的常量。

五、包装类的equals方法

1、方法结论

1.1结论

equals方法为true时，需要满足两个条件：

1、类型相同2、内容相同

1.2源码分析

(1)Integer的equals源码

public boolean equals(Object obj) {

if (obj instanceof Integer) {

return value == ((Integer)obj).intValue();

}

return false;

}

(2)Short的equals源码

public boolean equals(Object obj) {

if (obj instanceof Short) {

return value == ((Short)obj).shortValue();

}

return false;

}

(3)Long的equals源码

public boolean equals(Object obj) {

if (obj instanceof Long) {

return value == ((Long)obj).longValue();

}

return false;

}

(4)Character的equals源码

public boolean equals(Object obj) {

if (obj instanceof Character) {

return value == ((Character)obj).charValue();

}

return false;

}

(5)Byte的equals源码

public boolean equals(Object obj) {

if (obj instanceof Byte) {

return value == ((Byte)obj).byteValue();

}

return false;

}

(6)Float的equals源码

public boolean equals(Objectobj) {

return (obj instanceof Float)

&& (floatToIntBits(((Float)obj).value) ==floatToIntBits(value));

}

(7)Double的equals源码

public boolean equals(Objectobj) {

return (obj instanceof Double)

&& (doubleToLongBits(((Double)obj).value) ==

doubleToLongBits(value));

}

(8)Boolean的equals源码

public boolean equals(Objectobj) {

if (obj instanceof Boolean) {

returnvalue == ((Boolean)obj).booleanValue();

}

return false;

}

六、包装类一些结论总结

1、当一个基础数据类型与封装类进行==运算时，会将封装类进行拆箱

2、+运算时，会将封装类进行拆箱

3、当封装类与基础类型进行==运行时，封装类会进行拆箱，拆箱结果与基础类型对比值；

而两个封装类进行==运行时，与其它的对象进行==运行一样，对比两个对象的地址，也即判断是否两个引用是否指向同一个对象。

4、陷阱一：有拆箱操作时一定要特别注意封装类对象是否为null，如果为空，则不能调用对象的任何方法，否则会报错

5、陷阱二：不同范围数值的对象产生情况不同(详情看：四、包装类装箱之valueOf方法之思)

该结论来自以下参考文章，如果想了解详细，请看该文

博文：详解Java的自动装箱与拆箱(Autoboxingand unboxing)

博主：Mirhunana

网址：http://blog..net/hp910315/article/details/48654777

七、包装类综合实例应用

package wrapper;

public class Test {

public static void main(String[] args) {

/*

* 当 "=="运算符的两个操作数都是包装器类型的引用，则是比较指向的是否是同一个对象，

* 而如果其中有一个操作数是表达式(即包含算术运算)则比较的是数值(即会触发自动拆箱的过程)。

* 另外，对于包装器类型，equals方法并不会进行类型转换

*/

Integer a = 1;

Integer b = 2;

Integer c = 3;

Integer d = 3;

Integer e = 321;//大于一个字节表示范围(byte:-128-127)

Integer f = 321;

Long g = 3L;

Long h = 2L;

//如果装箱的是一个字节，该数据会被共享不会重新开辟空间

System.out.println(c==d);//true

System.out.println(e==f);//false

/*

* a+b包含了算术运算，因此会触发自动拆箱过程(会调用intValue方法)，

* 因此它们比较的是数值是否相等。

*

* 而对于c.equals(a+b)会先触发自动拆箱过程，再触发自动装箱过程，

* 也就是说a+b，会先各自调用intValue方法，得到了加法运算后的数值之后，

* 便调用Integer.valueOf方法，再进行equals比较。同理对于后面的也是这样，

* 不过要注意倒数第二个和最后一个输出的结果(如果数值是int类型的，

* 装箱过程调用的是Integer.valueOf；如果是long类型的，装箱调用的Long.valueOf方法)

*/

/*

* 3=(1+2)

* a+b包含了算术运算，因此会触发自动拆箱过程(会调用intValue方法)，

* 因此它们比较的是数值是否相等。

*/

System.out.println(c==(a+b));//true

/*

* 3.equals(1+2)

* 先自动拆箱，左边数值为3，右边数值为3；

* 然后出发自动装箱，装箱过程中调用Integer.valueOf方法，

* 即：如果装箱的是一个字节，该数据会被共享不会重新开辟空间

* 过左边和右边是同一个空间的地址，所以相等

*/

System.out.println(c.equals(a+b));//true

// System.out.println("3L==(1+2)--"+(3L==(1+2)));

/*

* 3L==(1+2)

* a+b包含了算术运算，因此会触发自动拆箱过程(会调用intValue方法)，

* 因此它们比较的是数值是否相等。

* 左边为3L 右边为3 ，两者的值相等吗？

* 相等：int与 long进行运算、比较时 int 会自动进行类型提升为 long类型

* 类型自动提升

*/

System.out.println(g==(a+b));//true

/*

* 3L.equals(1+2)

* 先自动拆箱，左边数值为3L，右边数值为3；

* 然后出发自动装箱，装箱过程中左边调用Double.valueOf方法，右边调用Integer.valueOf方法

* 左边为Long型，右边为Integer型(原因：类型不同，内容相同)

*/

System.out.println(g.equals(a+b));//false

/*

* 3L.equals(1+2L)

* 先自动拆箱，左边数值为3L，右边数值为3L(运算的时候，由于自动类型转换，所以为3L)；

* 然后出发自动装箱，装箱过程中两边都调用Double.valueOf方法

* 两边数值相等，故相等(类型和内容相同)

*/

System.out.println(g.equals(a+h));//true

}

}

八、参考文章

1、参考文章一

来源：博客

博文：Java 自动装箱和拆箱

博主：jackiehff

网址：http://blog..net/jackiehff/article/details/8509056

2、参考文章二

来源：

博文：深入剖析Java中的装箱和拆箱

博主：海 子

网址：http://www..com/dolphin0520/p/3780005.html

3、参考文章三

来源：博客

博文：Java自动装箱与拆箱及其陷阱

博主：JairusChan

网址：http://blog..net/jairuschan/article/details/7513045

4、参考文章四

来源：博客

博文：详解Java的自动装箱与拆箱(Autoboxing and unboxing)

博主：Mirhunana

网址：http://blog..net/hp910315/article/details/48654777