这里主要通过阅读源码了解character的一些特性

Character类的结构

public final
class Character implements java.io.Serializable, Comparable<Character> {
……………………
private final char value;
}

可以看到类无法覆盖父类，同时实现了序列化接口和比较接口。存储内容的char型变量为final，无法被修改值。
这里有一个很有意思的类CharacterCache，代码如下：

private static class CharacterCache {
        private CharacterCache(){}
        static final Character cache[] = new Character[127 + 1];
        static {
            for (int i = 0; i < cache.length; i++)
                cache[i] = new Character((char)i);
        }
    }

仔细观察接下去的代码我们可以知道，这个类相当于字符集合的一个缓存机制。这里有一个类方法（工厂方法）可以产生Character对象，首先将从cache中取值。

public static Character valueOf(char c) {
        if (c <= 127) { // must cache
            return CharacterCache.cache[(int)c];
        }
        return new Character(c);
    }

Integer类的结构

public final class Integer extends Number implements Comparable<Integer> {
private final int value;
…………………………
 public Integer(int value) {
        this.value = value;
    }
    public Integer(String s) throws NumberFormatException {
        this.value = parseInt(s, 10);
    }
}
// 可以看到比较值的运算时直接使用值的
 public int compareTo(Integer anotherInteger) {
        return compare(this.value, anotherInteger.value);
    }
  public static int compare(int x, int y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }

这里可以看到Integer主要的内容存储方式是和Character极为相似的，除此之外，Integer也有Cache。

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

这里可以看到Integer同样有cache，也同样有工厂方法在产生对象的时候使用cache中存储的变量。这里的大小是-128——127。

Integer的一些特性

// 用于数字字符串的转换
 final static char[] digits = {
        '0' , '1' , '2' , '3' , '4' , '5' ,
        '6' , '7' , '8' , '9' , 'a' , 'b' ,
        'c' , 'd' , 'e' , 'f' , 'g' , 'h' ,
        'i' , 'j' , 'k' , 'l' , 'm' , 'n' ,
        'o' , 'p' , 'q' , 'r' , 's' , 't' ,
        'u' , 'v' , 'w' , 'x' , 'y' , 'z'
    };
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);
        }
        // 我们可以知道int类型是四个字节32位的数
        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] = '-';
        }
          //根据内容创建新的String类型对象
        return new String(buf, charPos, (33 - charPos));
    }

上述的是普通的toString，从函数体中我们看到当radix==10使，显然使用的是其他的策略。

public static String toString(int i) {
        if (i == Integer.MIN_VALUE)
            return "-2147483648";
//StringSize缓存9、99……的int表，从而返回相应的int类型长度
        int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
        char[] buf = new char[size];
        getChars(i, size, buf);
        return new String(buf, true);
    }
static void getChars(int i, int index, char[] buf) {
        int q, r;
        int charPos = index;
        char sign = 0;

        if (i < 0) {
            sign = '-';
            i = -i;
        }

        // Generate two digits per iteration
        while (i >= 65536) {
            q = i / 100;
        // really: r = i - (q * 100);将乘法转化为位运算
            r = i - ((q << 6) + (q << 5) + (q << 2));
            i = q;
            buf [--charPos] = DigitOnes[r];
            buf [--charPos] = DigitTens[r];
        }

        // Fall thru to fast mode for smaller numbers
        // assert(i <= 65536, i);
        for (;;) {
        //这个核心算法反正我是没法理解，以后再理解吧
            q = (i * 52429) >>> (16+3);
            r = i - ((q << 3) + (q << 1));  // r = i-(q*10) ...
            buf [--charPos] = digits [r];
            i = q;
            if (i == 0) break;
        }
        if (sign != 0) {
            buf [--charPos] = sign;
        }
    }

总结

1.Character和Integer都有缓存机制，character为0——127、Integer为-128——127。
2.Integer类型的toString过程中显然用缓存字符矩阵的方法提高效率。此外，可以发现，源码的扩大十倍可以用等价的位运算来替代。