Integer a = new Integer(127);
Integer b = new Integer(127);
System.out.println(a==b);//false
System.out.println(a.equals.(b));//true
------------------------------------------
如果数值在btye类型范围内，如果该对象数值重复出现，多个引用其实指向同一个
Integer对象
但是如果超出byte范围，都会生产新的Integer对象
Integer i = 127;
Integer j = 127;
System.out.println(a==b);//true
System.out.println(a.equals.(b));//true

Integer i = 128;
Integer j = 128;
System.out.println(a==b);//false  产生了新的Interger对象
System.out.println(a.equals.(b));//true  比较的是对象里边的值
这是我的心得
我想问一下Integer的自动拆箱和装箱机制到底是咋回事啊，求底层？？？？

直接去看源码吧....

/**
     * Returns an {@code Integer} instance representing the specified
     * {@code int} value.  If a new {@code Integer} instance is not
     * required, this method should generally be used in preference to
     * the constructor {@link #Integer(int)}, as this method is likely
     * to yield significantly better space and time performance by
     * caching frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  i an {@code int} value.
     * @return an {@code Integer} instance representing {@code i}.
     * @since  1.5
     */
    public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

注意区别是有没有new对象哦，就返回值而论的话。
观摩源文件回来，其实自己是知道这个道理的，但是源文件里面究竟是怎样写的还是不知道哦，帮你拿出来了，附带注释

自动装箱/拆箱

在介绍“自动装箱/拆箱”机制前，先让我们来了解两个概念：
1）装箱：将一个值封装成为一个对象的过程
        Integer iobj = new Integer( 100 ) ;
2）拆箱：从一个类型包装器中提取值的过程
        int i = iobj.intValue() ;

注：拆箱、装箱的概念从Java第一个版本开始就存在，并不是Java1.5新特性，注意我们说的是“自动拆箱/拆箱”

从J2SE5将自动装箱/拆箱的概念引入到Java中。
自动装箱：每当我们需要一种类型的对象时，基本数据类型就被自动封装到与它相同类型的包装器中，并返回

自动拆箱：当我们需要一个值时，这个被装箱到对象中的值就会被自动的提取出来，不需要我们手动去调用xxValue()方法。

    自动装箱/拆箱机制的引入，大大简化了编程，免除了对值进行手工装箱/拆箱繁琐的工作，同时可以避免发生错误。而且，它对泛型有十分重要的作用。

    自动装箱引入，不需要手工建立一个对象来包装一个基本类型，只需将一个基本类型直接赋值给类型包装器，Java会自动建立一个对象：
        Integer iob = 100 ;  //auto-box
    自动拆箱引入，只要将这个对象引用赋给一个基本类型变量即可：int i = iob ;  //auto-unbox

1）方法中自动装箱/拆箱：
自动装箱/拆箱会在传递一个参数给方法或者方法返回一个值时自动发生。
class AutoBox{
    static int m( Integer v ){
        return v ;
    }
    public static void main( String [] args ){
        System.out.println( m(100 ) ;
    }
}

2）表达式中的自动装箱/拆箱

Integer iob = new Integer( 100 ) ;
++iob ;
System.out.println( iob * 20 + 10 ) ;

3）布尔型及字符型的自动装箱/拆箱
Boolean b = true ;    //auto-box
if( b ) System.out.println( "true" ) ; //auto-unbox
Character ch = 'x' ;   //auto-box
char ch2 = ch ;         //auto-unbox
当一个Boolean对象用作while、for、do...while条件表达式，它被自动拆箱为一个基本类型布尔值。

4）自动装箱/拆箱有助于避免错误发生

Integer iob = 1000 ;
int i = iob.byteValue() ;
System.out.println( i ) ;   // -24，iob中的值能过调用byteValue()被自动拆箱，使存储在iob中的值1000被截取，得到垃圾数据-24
通常，自动装箱总是生成一个正确的对象，而自动拆箱总是生成一个正确的值

5）关于自动装箱/拆箱建议

    到此，可能有人会说了，既然Java可以自动装箱/拆箱，还要基本数据类型干什么，而将基本类型全盘抛弃。虽然不使用基本数据类型完全可以，但它比起使用基本数据类型来说，它的效率要低得多，原因是自动装箱/拆箱增加了额外的系统负担，而基本类型则不会。

    所以，通常情况下，类型包装器只是在基本类型需要用对象表示的场合下才使用，毕竟自动装箱/拆箱并不是为了消除基本数据类型才被加入到Java中的。

java设计的，如果大于127才创建对象，小于不创建，优化内存的设计

1. 
   
2. Integer a = new Integer(127);
   
3. Integer b = new Integer(127);
   
4. System.out.println(a==b);//false
   
5. System.out.println(a.equals.(b));//true

复制代码

第一个为什么输出结果不一样！
显而易见的。两个对象都是new出来的。既开辟了新的存储空间。
那么就意味着两个对象不在同一个内存地址中。所以，==表达式会判断是false，equals则是true。
具体为什么会产生这样的误差，请参看：http://bbs.itheima.com/forum.php?mod=viewthread&tid=20534

1. Integer i = 127;
   
2. Integer j = 127;
   
3. System.out.println(a==b);//true
   
4. System.out.println(a.equals.(b));//true

复制代码

这里创建的i和j都指向了127这空间。所以结果怎么比较都会一样，因为指向的内存空间都是一致的。

1. Integer i = 128;
   
2. Integer j = 128;
   
3. System.out.println(a==b);//false  产生了新的Interger对象
   
4. System.out.println(a.equals.(b));//true  比较的是对象里边的值

复制代码

不在Integer范围，则找不到128的内存地址，则创建新的对象。道理同代码一。


至于装箱和拆箱的概念。则是封装，和取数据的概念。