Java底层基础-Integer底层源码分析

妖狐艹你老母 2022-12-29 09:25 293阅读 0赞

## 一、Integer简介 ##

Integer类时int基本数据类型的封装类；

*  Integer类和int的区别
    
    > Integer 是 int 包装类，int 是八大基本数据类型之一（byte,char,short,int,long,float,double,boolean）  
    > Integer 是类，默认值为null，int是基本数据类型，默认值为0；  
    > Integer 表示的是对象，用一个引用指向这个对象，而int是基本数据类型，直接存储数值。

## 二、源码分析 ##

### 1. 继承关系 ###

final修饰类，所以Integer类不能被继承和修改（与String一样，每次操作都会新生成一个对象，对形参的修改，实参不受影响）  
Integer继承了Number类，所以该类可以调用longValue、floatValue、doubleValue等系列方法返回对应的类型的值  
Integer类实现了Comparable接口（这个接口只有compareTo一个方法），可以用compareTo进行比较，  
并且Integer对象只能和Integer类型的对象进行比较，不能和其他类型比较（至少调用compareTo方法无法比较）  
Integer通过Number实现了序列化接口，可以进行序列化

public final class Integer extends Number implements Comparable<Integer>

### 2. 成员变量 ###

// 最小取值是 -2^31
    	@Native public static final int   MIN_VALUE = 0x80000000;
    	// 最大取值是2^31-1
    	@Native public static final int   MAX_VALUE = 0x7fffffff;
    	// 表示是基本类型int的calss实例
    	public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");
    	// 实际存放的值value
    	private final int value;

### 3. 构造函数 ###

在Integer类中提供了两个构造函数，分别针对构造参数为基本类型int和引用类型String.这两个方法都是给当前的实例的value属性赋值，参数为int类型；构造器直接将参数赋值给value属性，参数为String类型是调用了方法parseInt。

//当我们使用new Integer(10)创建一个Integer对象的时候，就会用以下形式给value赋值
    	public Integer(int value) { 
            this.value = value;
        }
        //当我们使用Integer a = new Integer("2")创建一个Integer对象的时候 ,创建的是String 参数所指示的 int 值
        public Integer(String s) throws NumberFormatException { 
        	//从构造方法中我们可以知道，初始化一个Integer对象的时候只能创建一个十进制的整数。
            this.value = parseInt(s, 10);
        }

### 4. 私有内部类 ###

IntegerCache是Integer的内部类，用来缓存了low-high之间数字的包装类，这个类是私有且静态的，并且有三个被final修饰的静态变量外加一个静态代码块和一个私有构造函数；被缓存的包装类介于low-high之间，low的值已经写死为-128，high值由虚拟机决定。  
**sun.misc.VM.getSavedProperty(“java.lang.Integer.IntegerCache.high”)** 是一个参数，可以动态设置。然后在循环中将low-high之间数字的装箱后方法cache\[\]这个Integer类型的数组中。这样就完成了缓存

private static class IntegerCache { 
           static final int low = -128;
           static final int high;
           static final Integer cache[];
    
           static { 
               // 缓存范围的最大值，可从配置文件配置
               int h = 127;
               String integerCacheHighPropValue =
                   sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
               if (integerCacheHighPropValue != null) { 
                   try { 
                       int i = parseInt(integerCacheHighPropValue);
                       // 获取配置文件i和127之间的最大值
                       i = Math.max(i, 127);
                       // 缓存范围不能超过Integer.MAX_VALUE-(-low)-1
                       h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                   } catch( NumberFormatException nfe) { 
                       // If the property cannot be parsed into an int, ignore it.
                   }
               }
               high = h;
               // 创建缓存
               cache = new Integer[(high - low) + 1];
               int j = low;
               // 将low-high之前的包装类缓存起来
               for(int k = 0; k < cache.length; k++)
                   cache[k] = new Integer(j++);
    
               assert IntegerCache.high >= 127;
           }
    
           private IntegerCache() { }
       }

### 5. toString 方法 ###

这个方法内部调用了两个方法：stringsize和getChars，toString方法的实现也就是由这两个方法合作完成。stringSize主要是计算出参数i的位数，也就是转化为字符串之后的字符串长度。

public static String toString(int i) { 
           if (i == Integer.MIN_VALUE)
               return "-2147483648";
           // 这边stringSize主要是计算i为正数时的位数，+1主要是‘-’号也是一个位数
           int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
           char[] buf = new char[size];
           getChars(i, size, buf);
           return new String(buf, true);
       }   
    
       static int stringSize(int x) { 
           for (int i=0; ; i++)
               if (x <= sizeTable[i])
                   return i+1;
       }
       final static int [] sizeTable = {  9, 99, 999, 9999, 99999, 999999, 9999999,99999999, 999999999, Integer.MAX_VALUE };
    
       static void getChars(int i, int index, char[] buf) { 
           int q, r;
           int charPos = index;
           char sign = 0;	//符号位
    
           // 将负数转换为正数，并赋值符号位
           if (i < 0) { 
               sign = '-';
               i = -i;
           }
    
           // 当大于65536的时候每两位数开始操作，假设i=65536（2^16）
           while (i >= 65536) {    
           	// 65536/100 = 655
               q = i / 100;		
               // 65536 - 655*100 = 36 这里使用了技巧
               //（q << 6) + (q << 5) + (q << 2）相等于655*100 同时证明位移和加法性能高于乘法
               r = i - ((q << 6) + (q << 5) + (q << 2));
               i = q;
               // 得到36的个位6，放数组最后一位
               buf [--charPos] = DigitOnes[r];
               // 得到36的个位3，依次放入
               buf [--charPos] = DigitTens[r];
           }
    
           // 对于娇小的数字，切换到快速模式，一位一位处理
           // assert(i <= 65536, i);
           for (;;) { 
           	// 相当于除以10 同时证明乘法和位移效率高于除法 
           	// 为什么选择524288=2^19 : 524280*524288 = 0.1000003
               q = (i * 524290) >>> (16+3);   
               // r = i-(q*10) 相当于乘以10，取i的个位数
               r = i - ((q << 3) + (q << 1));  
               // 将i的最后一位数存放在数组中
               buf [--charPos] = digits [r];
               i = q;
               if (i == 0) break;
           }
           // 存放符号位
           if (sign != 0) { 
               buf [--charPos] = sign;
           }
       }

## 三、自动拆箱装箱 ##

### 1. 装箱（基本类型的数据->包装类） ###

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

### 2. 拆箱（包装类->基本类型的数据） ###

public int intValue() { 
            return value;
        }

### 3. 应用 ###

public static void main(String[] args) { 
            //自动装箱,Integer a = 5等同于Integer a = Integer.valueOf(5)方法自动装箱；
            Integer a = 1;
            //先是自动拆箱，因为a是个包装类没法直接参与运算，所以调用a.intValue()方法拆成int型数据进行数据的计算
            a = a + 2;
            //然后在进行装箱；调用方法Integer.value(8)方法转换为integer类装箱。
            System.out.println(a);
    
            //ArrayList无法直接存储整数，可以存储Integer包装类
            ArrayList<Integer> list=new ArrayList<>();
            list.add(2);//自动装箱，将3使用Integer.valueOf(3)的方法，装箱进去。
            System.out.println(list.get(0));//自动拆箱。
        }

## 常见面试题讲解 ##

### 1. 不可修改类相关（String与此一致） ###

//解释下不可修改类
    	public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException { 
            Integer a = Integer.valueOf(1000);
            //Integer a = 1000
            Integer b = Integer.valueOf(2000);
            //Integer b = 2000
            System.out.println("交换前：" + "a = " + a + " " + "b = " + b);    // 交换前：a = 1000 b = 2000
            swap(a, b);
            System.out.println("交换后：" + "a = " + a + " " + "b = " + b);    // 交换后：a = 2000 b = 2000
        }
    
        public static void swap(Integer a,Integer b) throws NoSuchFieldException, IllegalAccessException { 
            // Field
            Field field = Integer.class.getDeclaredField("value");
            field.setAccessible(true);
            Integer temp = a;
            //Field.set()向对象的这个Field属性设置新值value
            field.set(a, b);
            field.set(b, temp);
    	}
    	// 疑问： 为什么a=2000 b=2000? 
    	// 因为Integer temp = a; 这个操作实际上是temp和a两个引用同时指向一个value的值. <a.value=temp.value=1000>
    	// 而field.set(a, b);这个操作改变了a的value的同时也改变了temp的value. <a.value=temp.value=2000>
    	// field.set(b, temp); 这个操作最终又将temp指向的value赋值给了b. <b.value=temp.value=2000>
    	// 所以最终结果是a.value=b.value=temp.value=2000
    	// 要想实现不可实现类之间的交换，应把“Integer temp = a;”换成“Integer temp = new Integer((Integer)field.get(a));” 这样对a进行操作时不会影响到temp

### 2. 与IntegerCache和拆箱装箱有关 ###

#### 2.1 题目1 ####

public static void main(String[] args) throws Exception{ 
    		Integer a=100;
    		Integer b=100;
    		Integer c=200;
    		Integer d=200;
    		System.out.println(a==b); //true
    		System.out.println(c==d); //false
    	}
    	// 疑问 为什么c==d返回是false?
    	// 首先 Integer x = number 实际上等于 Integer x = Integer.valueOf(number);(拆箱装箱)
    	// 其次 Integer内部使用了IntegerCache缓存，对-128至127之内的所有Integer包装类都进行了缓存
    	// 然后 通过valueOf()这个方法知，当获取这个区间内的值时是直接返回缓存中的对象，如果获取的值不是这个区间，则会重新创建一个新的对象
    	// 因为a和b是在这个区间内，所以直接返回了缓存中的同一个对象，即a==b返回为true
    	// c和d不在这个缓存区间中，所以都会产生一个新的对象，即c==d返回为false。

#### 2.2 题目2 ####

public static void main(String[] args) throws Exception{ 
            Integer a = 1;
            System.out.println("修改前a = "+a);
            System.out.println("====使用反射修改a的值====");
    
            Field field = Integer.class.getDeclaredField("value");
            field.setAccessible(true);
    
            field.set(a,2);
            System.out.println("修改后a = "+a);    // 结果a=2
    
            Integer c = 1;
            System.out.println("c = "+c);		  // 结果c=2
        }
        // 疑问 为什么c=2?
        // 首先 Integer x = number 实际上等于Integer x = Integer.valueOf(number);(装箱拆箱)
        // 其次 Integer内部使用了IntegerCache缓存，对-128至127之内的所有Integer包装类都进行了缓存
        // 然后 通过valueOf()这个方法知，当获取这个区间内的值时是直接返回缓存中的对象(即IntegerCache[i-low])
        // 所以知 Integer a = 1; 可以等同于 Integer a = Integer.valueOf(1) = IntegerCache[129]
        // 同理 Integer c = 1; 等同于 Integer c = Integer.valueOf(1) = IntegerCache[129], 即两者指向同一个对象
        // field.set(a,2);这个操作实际上是将IntegerCache[129]的值改为2 即IntegerCache[129]=2
        // 由于c和a指向同一个对象，所以a通过反射改变了value值也会影响到c的value值