一、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包中都有一个相应的包装类，包括有：

此外，在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 = new Integer(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 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方法具体是：

1     public boolean equals(Object obj) {
2         if (obj instanceof Integer) {
3             return value =http://www.mamicode.com/= ((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来显式创建新对象时，虚拟机只会将引用指向已经存在的结果。

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