public static String toString(int i, int radix) {

         if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)

             radix = 10;

         /* Use the faster version */

         if (radix == 10) {

             return toString(i);

         }

         char buf[] = new char[33];

         boolean negative = (i < 0);

         int charPos = 32;

         if (!negative) {

             i = -i;

         }

         while (i <= -radix) {

             buf[charPos--] = digits[-(i % radix)];

             i = i / radix;

         }

         buf[charPos] = digits[-i];

         if (negative) {

             buf[--charPos] = '-';

         }

         return new String(buf, charPos, (33 - charPos));

     }

 //定义一个Integer 变量

 Integer i = 1;

 Integer j = 1;

 System.out.println(i==j); //true

 Integer x = 128;

 Integer y = 128;

 System.out.println(x==y); //false

 /**

      * Cache to support the object identity semantics of autoboxing for values between

      * -128 and 127 (inclusive) as required by JLS.

      *

      * The cache is initialized on first usage.  The size of the cache

      * may be controlled by the -XX:AutoBoxCacheMax=<size> option.

      * During VM initialization, java.lang.Integer.IntegerCache.high property

      * may be set and saved in the private system properties in the

      * sun.misc.VM class.

      */

     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) {

                 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);

             }

             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() {}

     }

     /**

      * Compares two {@code int} values numerically.

      * The value returned is identical to what would be returned by:

      * <pre>

      *    Integer.valueOf(x).compareTo(Integer.valueOf(y))

      * </pre>

      *

      * @param  x the first {@code int} to compare

      * @param  y the second {@code int} to compare

      * @return the value {@code 0} if {@code x == y};

      *         a value less than {@code 0} if {@code x < y}; and

      *         a value greater than {@code 0} if {@code x > y}

      * @since 1.7

      */

     public static int compare(int x, int y) {

         return (x < y) ? -1 : ((x == y) ? 0 : 1);

     }