从头再学java系列之int和Integer的区别及Integer的源码分析

int 和Integer类的区别：

1.Integer是int的包装类，所以，利用Integer创建出来的是一个实例，而int则是一种基本的数据类型。Integer需要实例化才能使用，而int不需要。【在jdk5之后，jdk帮我们省去了开箱和封箱的操作了】如果有不明白封箱和开箱的朋友，可以看看这个
博文里面有封箱和开箱的解析

        Integer a=12;
        Integer b=12;
        int c=12;
        int d=12;
        System.out.println(a==b);//True
        System.out.println(c==d);//True

既然说Integer是一个类，那么，a和b应该是两个不同的对象【类是一个对象的抽象，对象是一个类的实例】。所以，a和b的地址应该是不一样的。但是为什么这里a==b居然是true呢？

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

Integer类的源码：上面是一段Integer类的源码，有一句 static Integer cache[],字面意思是啥，Integer类的缓存。 low=-128,high=127.这段源码的意思就是，利用Integer类创建对象，在-128-127之间是有进行缓存的。如果创建的数值是在这个范围之内，是不会去创建新的对象的。
所以，测试一下：

 Integer a=-128;
        Integer b=-128;
        System.out.println(a==b);//true

        Integer c=-129;
        Integer d=-129;
        System.out.println(c==d);//false

        Integer e=127;
        Integer f=127;
        System.out.println(e==f);//true

        Integer g=128;
        Integer h=128;
        System.out.println(g==h);//false

验证了猜想。

int和Integer类的默认值

Integer的默认值是null，int的默认值是0【一时想不出什么测试方法】

必须使用Integer类的一些地方

如果是Map类型这种，<String,Integer>要求存入的类型是对象的，就不能够使用int，必须使用Integer类
总结：Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值。

Integer类的一些属性

4.Integer里面封装了int类的最大值和最小值，也就是我们平时使用的
带符号的情况下：Integer.MAX_VALUE和Integer.MIN_VALIUE.【源码】

@Native public static final int   MIN_VALUE = 0x80000000;
@Native public static final int   MAX_VALUE = 0x7fffffff;

        System.out.println(0x80000000);
        System.out.println(0x7fffffff);
        /*结果：
        最小值：-2147483648
        最大值：2147483647
        */

使用了八位十六进制的数来表示Integer的最大值和最小值，转化为二进制数，就是

        System.out.println(Integer.toBinaryString(-2147483648));
        System.out.println(Integer.toBinaryString(2147483647));

10000000000000000000000000000000
31个0和1个1，在计算机底层中，第一个位是符号位，1表示负数，0表示整数，所以，最小负数的第一位是1。
1111111111111111111111111111111，下面是31个1，表示最大整数，这个它的符号位被省略了，本来应该表示为01111111111111111111111111111111的。

找出两个数的最大值和最小值

5.Integer类里面封装了找出最大值和最小值的方法【实质上，就是调用了Math库里面的东西】但是这样调用，会耗费一点点时间，所以，在知道的情况下，直接使用Math库里面的方法就好了。

    public static int max(int a, int b) {
        return Math.max(a, b);
    }
    public static int min(int a, int b) {
        return Math.min(a, b);
    }

判断一个数的正负

Integer的signum方法：传入一个参数，返回这个参数的符号。

    public static int signum(int i) {
        return (i >> 31) | (-i >>> 31);
    }

移位运算的详解
传入正数：就返回1
传入负数，就返回-1
它的源码设计非常巧妙，a|b表示a与b都计算【非短路运算】，a||b会造成逻辑短路。

Integer类实现的接口

Integer类继承了Number类并实现了Comparable接口，代码如下，表示是一个可排序的类，如果这个对象你想要安装某种规则进行排序的话，那就必须实现这个接口。【Integer、String、Character都是有的】

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

而Number类实现了序列化接口，代码如下：

public abstract class Number implements java.io.Serializable {}

所以Integer类是一个可排序的，可序列化的类。

字符串转化为数字

public static int parseInt(String s) throws NumberFormatException {}
public static Integer valueOf(String s) throws NumberFormatException {}

这上面两个方法，都是将一个可转化为数字的字符串转为为整形【也就是说，该字符串里面不能包含有其他的非法字符】。两者的区别，从返回值类型上就可以看得非常清楚，一个是返回一个int类型，也就是一个整数，一个是返回一个Integer类型，是一个对象。

总结

这是自己一点点大概的心得吧，源码里面还有很多方法也是很常用的，但是太多太细致的我就不再仔细去研究了。