Java包装类，以及Integer与int之间的比较

一、Java的基本类型

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

1. 整数型，包括byte、short、int、long，默认初始值是0；
2. 浮点型，包括float、double，默认初始值是0.0；
3. 字符型，char型，默认值是''，注意跟“”的区别，''是字符的引号，“”是字符串的引号，两者不同。
4. 布尔型，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、本类型与其它类型转换

示例如下：

Integer temp1 = new Integer(45);
int temp2 = 45;

byte t1 =  temp1.byteValue();  //包装类的转换
byte t2 = (byte)temp2;  //基本数据类型的强制类型转换

 

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

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

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

示例如下：

 int a1=4;

//手动装箱
Integer aI1 = new Integer(a1);
//自动装箱
Integer aI2 = a1;

//手动拆箱
int ai1 = aI1.intValue();
//自动拆箱
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 class TestInteger {

    public static void main(String[] args) {
        int t1 = 46;
        int t2 = 46;
        Integer t3 = 46;
        Integer t4 = new Integer(46);
        Integer t5 = t1;
        Integer t6 = new Integer(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方法具体是：

    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

 

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

 

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

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