JAVA数据类型

基本数据类型	包装类
byte（字节）	java.lang.Byte
char（字符）	java.lang.Character
short（短整型）	java.lang.Short
int（整型）	java.lang.Integer
long（长整型）	java.lang.Long
float（浮点型）	java.lang.Float
double（双精度）	java.lang.Double
boolean（布尔型）	java.lang.Boolean

基本上就是一句话，除了8本基本的数据类型，其他的都是引用数据类型，如Long，Integer等，其主要目的就是提供一个对象实例作为壳，将其基本类型包到这个对象之中，然后提供很多操作数据的方法，使面向对象的编程变得更加容易。

Integer 

	public static void main(String[] args) {

		int a = 2;
		int b = 2;
		Integer c = 3;
		Integer d = 3;
		Integer e = 128;
		Integer f = 128;
		System.out.println(a == b);
		System.out.println(c == d);
		System.out.println(e == f);

	}

输出结果是：true，true，false

 整型值的比较很容易理解，就是值的大小比较

 但是为什么下面的语句会是不同的结果：

         System.out.println(c == d);
         System.out.println(e == f);

 从字节码上看都是一样的指令，没有不同的地方
 原因就在Integer的方法 valueOf

 我们来看这个方法的源码：字节码里调用的就是这个方法：

  public static Integer valueOf(int i) {
         if(i >= -128 && i <= IntegerCache.high)
             return IntegerCache.cache[i + 128];
         else
             return new Integer(i);
     }

 private static class IntegerCache {
         static final int high;
         static final Integer cache[];

         static {
             final int low = -128;

             // high value may be configured by property
             int h = 127;
             if (integerCacheHighPropValue != null) {
                 // Use Long.decode here to avoid invoking methods that
                 // require Integer's autoboxing cache to be initialized
                 int i = Long.decode(integerCacheHighPropValue).intValue();
                 i = Math.max(i, 127);
                 // Maximum array size is Integer.MAX_VALUE
                 h = Math.min(i, Integer.MAX_VALUE - -low);
             }
             high = h;

             cache = new Integer[(high - low) + 1];
             int j = low;
             for(int k = 0; k < cache.length; k++)
                 cache[k] = new Integer(j++);
         }

         private IntegerCache() {}
     }

 Integer里弄了一个缓存，对于在 -128—127 之间的数值，会直接使用该缓存里的对象
  也就是说 Integer c = 3 或者 Integer c = Integer.valueOf(3) ，最终 c 得到的是Integer里的缓存对象
  同理，d也是获得该相同对象因此 进行 c == d 比较时，c和d引用的是同一个对象，因此就true
  而对于128，已经超出缓存范围了，因此 valueOf 方法会生成一个新的Integer对象因此e和f就引用不同 的对象了，进行==比较，当然就false了
  另外，对Integer的缓存，我们在日常开发时，对于小的整型值应该充分利用Integer的缓存对象省去过多的对象创建，回收的操作，这样会极大的提高程序性能

int 是基本数据类型（面向过程留下的痕迹，不过是对java的有益补充），Integer 是一个类，是int的扩展，定义了很多的转换方法

　　类似的还有：float Float;double Double;string String等，而且还提供了处理 int 类型时非常有用的其他一些常量和方法

　　举个例子：当需要往ArrayList，HashMap中放东西时，像int，double这种内建类型是放不进去的，因为容器都是装 object的，这是就需要这些内建类型的外覆类了。

举例说明

　　ArrayList al=new ArrayList();

　　int n=40;

　　Integer nI=new Integer(n);

　　al.add(n);//不可以

　　al.add(nI);//可以

　　并且泛型定义时也不支持int: 如：List<Integer> list = new ArrayList<Integer>();可以  而List<int> list = new ArrayList<int>();则不行