jdk之java.lang.Integer源码理解

基本数据类型的包装类java.lang.Integer是我们频繁使用的一个系统类，那么通过一个示例反应出的几个问题来深入理解一下此类的源码。

需求：实现Integer类型的两个数值交换。

 package cn.integer;

 public class Demo {
     public static void main(String[] args) {
         Integer a = 1;
         Integer b = 2;
         System.out.println("bofore swap a:"+a+",b:"+b);
         //交换a和b的值
         swap(a,b);
         System.out.println("after swap a:"+a+",b:"+b);
     }
     /**
      * 数据交换
      * @param a
      * @param b
      */
     private static void swap(Integer a, Integer b) {
         /**
          * 如何实现呢？尝试几种方法
          */
         /*01.方式一（无法实现）
         a = a^b;
         b = a^b;
         a = a^b;*/

         /*02.方式二（无法实现）
         int tmp = a;
         a = b;
         b = tmp;*/

         /**
          * 以上两种方式是因为java的值传递特性故无法实现数据交换。
          */
     }
 }

Java值传递的示意图如下：

当调用swap(..)方法时，在堆中会创建这两个值得副本，形参num1和num2指向副本的数据。原ab指向的数据不会改变。

那么如何通过修改swap()方法实现呢？

观察java.lang.Integer源码：

public final class Integer extends Number implements Comparable<Integer> {
          ...
}

可以发现 Integer和String一样，是final修饰的，这是因为jdk将这些系统类封装起来不希望被破坏。

继续看Integer类：

 /**
     * The value of the {@code Integer}.
     *
     * @serial
     */
    private final int value;

    /**
     * Constructs a newly allocated {@code Integer} object that
     * represents the specified {@code int} value.
     *
     * @param   value   the value to be represented by the
     *                  {@code Integer} object.
     */
    public Integer(int value) {
        this.value = value;
    }

这里的value也是使用final修饰的，那么如果想修改它的值，可以使用反射的方式获取value字段并进行修改。

修改swap()方法中代码：

 public class Demo {
     public static void main(String[] args) {
         Integer a = 1;
         Integer b = 2;
         System.out.println("bofore swap a:"+a+",b:"+b);
         //交换a和b的值
         swap(a,b);
         System.out.println("after swap a:"+a+",b:"+b);
     }
     /**
      * 数据交换
      * @param a
      * @param b
      */
     private static void swap(Integer a, Integer b) {
         try {
             //获取Integer类中私有字段value
             Field field = Integer.class.getDeclaredField("value");
             /**
              * 开启访问权限
              * public final class Field extends AccessibleObject implements Member {}
              * 跟进AccessibleObject
              * public void setAccessible(boolean flag) throws SecurityException {
                     SecurityManager sm = System.getSecurityManager();
                     if (sm != null) sm.checkPermission(ACCESS_PERMISSION);
                     setAccessible0(this, flag);
                 }

                 private static void setAccessible0(AccessibleObject obj, boolean flag)
                     throws SecurityException
                     {
                         if (obj instanceof Constructor && flag == true) {
                         Constructor<?> c = (Constructor<?>)obj;
                         if (c.getDeclaringClass() == Class.class) {
                             throw new SecurityException("Cannot make a java.lang.Class" +
                                                 " constructor accessible");
                         }
                     }
                     obj.override = flag;
                 }
              */
             field.setAccessible(true);
             //临时变量
             int tmp = a.intValue();
             //数据交换
             field.set(a, b);
             field.set(b, tmp);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }

运行结果：

诶，我去。怎么只改变了一个值？咋成功了一半呢？

01.首先，Integer a = 1; 这里会自动装箱，将 int类型的1 转换成 Integer类型。

通过valueOf方法进行装箱

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

这个方法非常重要，如果传入的参数在 -128-127之间，会返回一个缓存中的数据。否则就 new出一个Integer对象！

Integer.IntegerCache是Integer中的内部类：

 private static class IntegerCache {
         static final int low = -128;
         static final int high;
         static final Integer cache[];

         static {
             // high value may be configured by property
             int h = 127;
             String integerCacheHighPropValue =
                 sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
             if (integerCacheHighPropValue != null) {
                 try {
                     int i = parseInt(integerCacheHighPropValue);
                     i = Math.max(i, 127);
                     // Maximum array size is Integer.MAX_VALUE
                     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;
             for(int k = 0; k < cache.length; k++)
                 cache[k] = new Integer(j++);

             // range [-128, 127] must be interned (JLS7 5.1.7)
             assert IntegerCache.high >= 127;
         }

         private IntegerCache() {}
     }

02.当我们获取数值1时，

return IntegerCache.cache[i + (-IntegerCache.low)] 
计算出IntegerCache.cache[129]的值（也就是1）返回。

cache这个数组存放着 -128-127这些数据。故index=129就是返回1。

03. 执行这行时  field.set(a, b);
将传入的2复制给a，此时a为2.
注意：这里通过set方法改变的的是缓存cache数组中的数据！

04. 当执行到 field.set(b, tmp);
tmp为1，而set方法的参数类型是Object，可以传入int类型的tmp

public void set(Object obj, Object value)
        throws IllegalArgumentException, IllegalAccessException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, obj, modifiers);
            }
        }
        getFieldAccessor(obj).set(obj, value);
    }

所以这个tmp=1是从Integer的缓存数组中取得，因上一行操作已经将cache中index为129位置得原数值1改变为了2，故在cache中获取的是2！ 那么把2赋值给了b自然是2！（b对应的下标[130],a对应的下标[129]）

我们发现，问题的关键在于这个缓存cache！

如果说可以避开走缓存这一步，我们就能实现数据交换。除了传入 -128-127之外的数据，我们还可以：

001.将tmp转换成Integer对象后在传入Field的set方法：

private static void swap(Integer a, Integer b) {
        try {
            //获取Integer类中私有字段value
            Field field = Integer.class.getDeclaredField("value");
            field.setAccessible(true);
            //临时变量
            int tmp = a.intValue();
            //数据交换
            field.set(a, b);
            field.set(b, new Integer(tmp));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

运行结果：

 002. 使用 Field类的 setInt方法

public void setInt(Object obj, int i)
        throws IllegalArgumentException, IllegalAccessException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, obj, modifiers);
            }
        }
        getFieldAccessor(obj).setInt(obj, i);
    }

修改代码 field.setInt(b,tmp); 也可以实现。

003. 非要实现打印效果的话，使用非常规手短，直接在swap中打印结果...

private static void swap(Integer a, Integer b) {
        System.out.println("after swap a:2,b:1");
        System.exit(0);
    }

这个示例中涉及到技能点：