java高效编程读书笔记- 基本类型优先于包装类型

java的类型分两部分，基本类型和引用类型。并且，每个基本类型都对应了一个引用的类型，称为装箱基本类型。

如Integer 对应int,Double对应的double.

 

两者的主要区别有三：

1. 基本类型只有值，而装箱类型则有与他们的值不同的同一性，也就是两个装箱类型可以具有相同的值，有不同的同一性（不同的引用）
2. 基本类型只有功能完备的值，而每个装箱类型除了它对应基本类型的所有功能值外，还有个非功能的值--null
3. 基本类型通常比装箱类型更节省时间和空间。

首先看装箱类型的同一性，自己写的一个比较函数代码如下：

// 比较器
  public int myCompare(Integer first, Integer second) {

         return first < second? -1 : (first==second ? 0 : 1);
	}

 

该函数用来表示Integer值的递增数字顺序。若第一个参数是小于，等于 或者大于它的第二个参数，则该方法返回负数，0或者正数.

 

但是该函数并不能正常的工作，当你调用 myCompare(new Integer(44), new Integer(44)),时，函数返回1.

但我们期待的是0。

原因是进行first<second比较时，系统自动对两个Integer对象被进行了自动拆箱，提取了基本类型的值，经过比较44<44不成立，则进行first==second的比较，这时系统进行的是同一性的比较，也就是比较两个包装类的引用，很明显不是同一个引用，所以函数返回1.

结论：对包装类用==操作符几乎总是错误的.

修改的方法是 新增加两个局部的值类型变量来替换。

	public int myCompare(Integer first, Integer second) {

		// 使用两个基本类型来转化，避免进行对象的同一性比较
	/*	int f = first;
		int s = second;
		return f < s ? -1 : (f == s ? 0 : 1);*/

		 return first < second? -1 : (first==second ? 0 : 1);
	}

 

再看下面的代码：

		Integer i1 = 100;  //自动装箱
		Integer i2 = 100;
		int j = 100;
		System.out.println(i1 == i2); 		        
                                System.out.println(i1 == j); 
		
                                Integer i3 = 128; //自动装箱
		Integer i4 = 128;
		int k = 128;
		System.out.println(i3 == i4); 
		System.out.println(i4 == k); 

 

以上代码分别输出结果是什么？

输出的结果是 true,ture,false,true

对于i1和i2的结果，我们很清楚明白，但是对于i3==i4的比较，为什么为false?

 

当将一个int值赋值给它的一个Integer包装类型变量时，Integer类型调用了valueOf方法：

    public static Integer valueOf(int i) {
	final int offset = 128;
	if (i >= -128 && i <= 127) { // must cache 
	    return IntegerCache.cache[i + offset];
	}
        return new Integer(i);

 

如果这个值在-128和127之间，则将该值进行了缓存处理，在内存中都是指向的一个包装类型对象.

 

也就是

Integer i1=100;

Integer i2=100;

Integer i3=100;

Integer i4=100;

...

Integer i100=100;

 

这些所有的Integer对象都是指向同一个对象地址空间的。

 

但是超过了这个区间，则分别创建的是不同的Integer对象.

查看IntegerCache中引用cache这个变量的部分：

private IntegerCache(){}

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

	static {
	    for(int i = 0; i < cache.length; i++)
		cache[i] = new Integer(i - 128);
	}

 

由于cache[]在IntegerCache类中是静态数组，也就是只需要初始化一次，即static｛......｝部分，所以，如果Integer对象初始化时是-128~127的范围，就不需要再重新定义申请空间，都是同一个对象---在IntegerCache.cache中，这样可以在一定程度上提高效率。

 

看另外的个例子：

	static Integer i;

	public void unbelieve() {
		if (i == 42) { // 这里将抛出空指向异常 因为自动装箱和拆箱的缘故，建议修改i的定义为int 或者和new
			// Integer(42)包装类型来比较
			System.out.println("不敢相信");
		}

 

这里不会输出"不敢相信",系统会报告NullPointerException异常。因为i被初始化为null，使用(i==42)时，因为i是Integer 类型，当包装类型和基本类型进行比较时，包装类型则会被自动拆箱，但i是一null，null对象引用被自动拆箱，则会得到一个NullPointerException异常。

修改的方法是将i定义为int或者将其和包装类进行比较，但同样要注意上面提到的-128~127这个区间的问题

 

另外一个关于性能的问题，看如下代码：

public static void main(String args[]){
    Long sum=0L;
    for(long i=0;i<Integer.MAX_VALUE;i++){
        sum=+i;       
    }
    System.out.println(sum);
}

这个程序中的的局部变量 sum 被声明为装箱类型Long,不是基本类型long,虽然编译和运行没有任何错误。但明显的，其在运行中被反反复复的装箱和拆箱，严重影响了性能。