class AutoUnboxingTest {

    public static void main(String[] args) {
        Integer a = new Integer(3);
        Integer b = 3;                  // 将3自动装箱成Integer类型
        int c = 3;
        System.out.println(a == b);     // false 两个引用没有引用同一对象
        System.out.println(a == c);     // true a自动拆箱成int类型再和c比较
    }
}

public class Test03 {

    public static void main(String[] args) {
        Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;

        System.out.println(f1 == f2);
        System.out.println(f3 == f4);
    }
}

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

/**
     * 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 {@code -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) {
                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() {}
    }

补充1：较新版本的Java（从Java 6的某个更新开始）中，由于JIT编译器的发展和"逃逸分析"技术的逐渐成熟，栈上分配、标量替换等优化技术使得对象一定分配在堆上这件事情已经变得不那么绝对了。
补充2：运行时常量池相当于Class文件常量池具有动态性，Java语言并不要求常量一定只有编译期间才能产生，运行期间也可以将新的常量放入池中，String类的intern()方法就是这样的。

String s1 = new StringBuilder("go")
    .append("od").toString();
System.out.println(s1.intern() == s1);
String s2 = new StringBuilder("ja")
    .append("va").toString();
System.out.println(s2.intern() == s2);

由于jdk1.7中将字符串常量池改为存放在堆中，因此intern()方法的实现原理相对以前的版本也有所改变。

我们根据jdk的版本来进行一些分析：

　　jdk1.6中字符串常量池存放在永久代中：

　　　　当使用intern()方法时，查询字符串常量池是否存在当前字符串，若不存在则将当前字符串复制到字符串常量池中，并返回字符串常量池中的引用。

　　jdk1.7中字符串常量池存放在堆中：

　　　　当使用intern()方法时，先查询字符串常量池是否存在当前字符串，若字符串常量池中不存在则再从堆中查询，然后存储并返回相关引用；

　　　　若都不存在则将当前字符串复制到字符串常量池中，并返回字符串常量池中的引用。

 

从上面叙述中，可以得出其中的区别：

　　jdk1.6中只能查询或创建在字符串常量池；

　　jdk1.7中会先查询字符串常量池，若没有又会到堆中再去查询并存储堆的引用，然后返回。

 

验证以上观点：　

String s = new String("1") + new String("2");
System.out.println(s.intern() == s);
　　jdk1.6中输出结果为 false

　　解释：

　　　　s.intern()查询字符串常量池中是否存在“12”后，将“12”复制到字符串常量池中并返回字符串常量池的引用。

　　　　而s存放在在堆中，返回false。

　　jdk1.7中输出结果为 true

　　解释：

　　　　s.intern()先查询字符串常量池中是否存在“12”后，再从堆中查询“12”是否存在并存储堆中的引用并返回。

　　　　因此s.intern()与s指向的是同一个引用，返回true。

 

借用美团技术团队《深入解析String#intern》一文中两段代码与相关图片来进行解释：

注：图中绿色线条代表 string 对象的内容指向。 黑色线条代表地址指向。

String s = new String("1");
s.intern();
String s2 = "1";
System.out.println(s == s2);

String s3 = new String("1") + new String("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4);

　jdk1.6中输出结果为 false false

　　解释：

　　　　String s = new String("1"); 在字符串常量池中创建"1"对象，在堆中创建s对象。

　　　　s.intern(); 由于字符串常量池中已经有"1"对象，因此该句并无实际意义。 s2指向字符串常量池中"1"对象。

　　　　因此s指向堆中的引用，s2指向字符串常量池中的引用，返回 false。

　　　　String s3 = new String("1") + new String("1"); 在堆中创建s3对象。

　　　　s3.intern(); 将字符串"11"复制到字符串常量池中。s4指向字符串常量池中"11"对象。

　　　　因此s3指向堆中的引用，s4指向字符串常量池中的引用，返回 false。

　jdk1.7中输出结果为 false true

　　解释：

　　　　s与s2的情况与jdk1.6中一样，返回 false。

　　　　s3与s4有所不同的是s3.intern(); 先在字符串常量池中查找是否存在"11"，再从堆中查找，

　　　　然后将堆中s3的引用存储到字符串常量池中。

　　　　String s4 = "11"; 创建的时候发现字符串常量池中有了“11”（s3），然后指向s3引用的对象。

　　　　因此s3与s4的引用相同，返回 true。

String s = new String("1");
String s2 = "1";
s.intern();
System.out.println(s == s2);

String s3 = new String("1") + new String("1");
String s4 = "11";
s3.intern();
System.out.println(s3 == s4);