java包装类引用比较_Java包装类，以及Integer与int之间的比较

一、Java的基本类型

Java语言中提供了八种基本类型，包括六种数字类型(四个整数型，两个浮点型)，一种字符类型，还有一种布尔型。

整数型，包括byte、short、int、long，默认初始值是0；

浮点型，包括float、double，默认初始值是0.0；

字符型，char型，默认值是''，注意跟“”的区别，''是字符的引号，“”是字符串的引号，两者不同。

布尔型，boolean，默认初始值是false。

注意：如果不初始化一个char类型的变量，将它输出在console的时候你看不到任何结果。Java中，字符型并不是用ASCII码来存储的，而是用16位的Unicode字符集来存储，它的范围就是字符集的范围，默认值是u000000。

二、包装类

包装类把基本类型转换为对象，每个基本类型在java.lang包中都有一个相应的包装类，包括有：

基本类型包装类型

byte

Byte

short

Short

int

Integer

long

Long

float

Float

double

Double

char

Character

boolean

Boolean

此外，在java.math包中还有两个用于数字计算的类型，分别是BigInteger、BigDecimal。它们无对应的基本类型，主要应用于高精度的运算，其中BigInteger 支持任意精度的整数运算，BigDecimal支持任意精度带小数点的运算，可以用于避免使用基本类型时产生的精度损失等问题。

三、包装类的用法

这里只讨论六种数字基本类型对应的包装类，因为它们是使用最频繁的，这些类中常用的方法可分为两类：一种是本类型与其它基本类型之间的转换，另一种是字符串与本类型和基本类型之间的转换。如下图，是Integer类中的一些常用方法：

其中的前五个，都是属于第一种，即与其它基本类型之间的转换。下面的三个则属于第二种，是字符串与本类型及基本类型之间的转换。

A、本类型与其它类型转换

示例如下：

1 Integer temp1 = new Integer(45);2 int temp2 = 45;3

4 byte t1 = temp1.byteValue(); //包装类的转换

5 byte t2 = (byte)temp2; //基本数据类型的强制类型转换

B、本类型和对应基本类型转换

JDK1.5引入了自动装箱和拆箱的机制，那么什么是装箱和拆箱呢？

装箱就是将基本类型转换成包装类，分为自动装箱和手动装箱。同样地，拆箱就是将包装类型转换成基本类型，也分为自动拆箱和手动拆箱。

示例如下：

1 int a1=4;2

3 //手动装箱

4 Integer aI1 = newInteger(a1);5 //自动装箱

6 Integer aI2 =a1;7

8 //手动拆箱

9 int ai1 =aI1.intValue();10 //自动拆箱

11 int ai2 = aI2;

C、字符串和基本类型转换

c1.基本类型转换成字符串类型

c1a.   包装类 的toString()方法

c1b.   String 类的valueOf()方法

c1c.   空字符串加一个基本类型变量

1 //基本类型转换成字符串类型有三种方法

2 int b = 1;3 String b1 =Integer.toString(b);4 String b2 =String.valueOf(b);5 String b3 = b+"";6 System.out.println("b1: "+b1+"b2: "+b2+"b3: "+b3);

c2.字符串转换成基本类型

c2a.   包装类的parse***()静态方法

c2b.   包装类的valueOf()方法

//字符串转换成基本类型的方法有两种String b= "121";int c1 =Integer.parseInt(b);int c2 = Integer.valueOf(b);

四、基本类型和包装类的异同

4.1   在Java中，一切皆对象，但八大基本类型却不是对象。

4.2   声明方式的不同，基本类型无需通过new关键字来创建，而包装类型需new关键字。

4.3   存储方式及位置的不同，基本类型是直接存储变量的值保存在堆栈中，能高效的存取，包装类型需要通过引用指向实例，具体的实例保存在堆中。

4.4   初始值的不同，包装类型的初始值为null，基本类型的的初始值视具体的类型而定。

4.5   使用方式的不同，如与集合类合作使用时只能使用包装类型。

五、Integer与int数据的比较

在Java中，因为有自动装箱/拆箱操作，所以int与Integer类型在比较大小时基本是没有差别的。

利用一段程序验证如下：

public classTestInteger {public static voidmain(String[] args) {int t1 = 46;int t2 = 46;

Integer t3= 46;

Integer t4= new Integer(46);

Integer t5=t1;

Integer t6= newInteger(t2);

System.out.println("t1 == t2 " + (t1 ==t2));

System.out.println("t1 == t3 " + (t1 ==t3));

System.out.println("t1 == t4 " + (t1 ==t4));

System.out.println("t1 == t5 " + (t1 ==t5));

System.out.println("t1 == t6 " + (t1 ==t6));

System.out.println("t4 == t2 " + (t4 ==t2));

System.out.println("t5 == t2 " + (t5 ==t2));

System.out.println("t6 == t2 " + (t6 ==t2));

System.out.println("t4 == t3 " + (t4 ==t3));

System.out.println("t5 == t3 " + (t5 ==t3));

System.out.println("t6 == t3 " + (t6 ==t3));

System.out.println("t3 equals t4 " +(t3.equals(t4)));

System.out.println("t3 equals t5 " +(t3.equals(t5)));

System.out.println("t3 equals t6 " +(t3.equals(t6)));

System.out.println("t3 equals t4 " +(t3.equals(t4)));

System.out.println("t4 equals t5 " +(t4.equals(t5)));

System.out.println("t4 equals t6 " +(t4.equals(t6)));

System.out.println("t5 equals t6 " +(t5.equals(t6)));

}

}

上面的程序中，分别利用针对变量和具体数字的两种装箱方式定义了四个Integer类的变量，

在后续的测试代码中分别使用了==和equals两种方式进行比较，其输出结果为：

t1 == t2 true

t1 == t3 true

t1 == t4 true

t1 == t5 true

t1 == t6 true

t4 == t2 true

t5 == t2 true

t6 == t2 true

t4 == t3 false

t5 == t3 true

t6 == t3 false

t3 equals t4 true

t3 equals t5 true

t3 equals t6 true

t3 equals t4 true

t4 equals t5 true

t4 equals t6 true

t5 equals t6 true

使用equals方式的比较中，所有的结果都是true。Integer类中的equals方法具体是：

1 public booleanequals(Object obj) {2 if (obj instanceofInteger) {3 return value ==((Integer)obj).intValue();4 }5 return false;6 }

从代码可以看出，两个Integer类的equals方法最终比较的是，其各自所包装的intValue的值是否相等，因此，所有的输出结果都是true。

在使用==比较的时候，输出结果中有两个是false，都是在两个Integer类比较时产生的。因为当==比较的一个Integer类和一个int变量时，自动装箱/拆箱会对其进行处理，最终比较的是数值结果。当面对两个Integer类时，==所比较的是两个引用所指的是否为同一对象。而在上面的程序中，t4和t6都是通过new创建出的新对象，因此它们与前面的t3是完全不同的引用，所以结果是false。

值得注意的是t3和t5的比较结果，针对数值46和int变量t1的自动装箱结果指向的是同一个Integer对象，这说明在这段程序中，没有使用new来显式创建新对象时，虚拟机只会将引用指向已经存在的结果。