【解惑】让人头疼的"相等"关系

//代码1：整型包装器的"=="比较
Integer n1=new Integer(1); 
Integer n2=new Integer(1);
if(n1==n2); //false

//代码2：整型变量的"=="比较
int n3=1;
int n4=1;
if(n3==n4); //true 

0 new java.lang.Integer [16] //在堆中分配一个Integer对象n1的空间，并将对象引用(堆地址)压入操作数栈 
3 dup //复制对象n1的引用压入操作数栈 
4 iconst_1 //将一个整型长度的常量1压入操作数栈
5 invokespecial java.lang.Integer(int) [18] //弹出整型常量1和对象n1的引用，对堆中对象n1的实例数据进行初始化 
8 astore_1 [n1] //弹出对象n1的引用，并将其保存在局部变量区的第1个位置上。 
9 new java.lang.Integer [16] //对象n2同上 
12 dup 
13 iconst_1 
14 invokespecial java.lang.Integer(int) [18] 
17 astore_2 [n2] //将对象n2的引用保存在局部变量区的第2个位置上 
18 aload_1 [n1] //将局部变量1中的n1对象引用压入操作数栈 
19 aload_2 [n2] //将局部变量2中的n2对象引用压入操作数栈 
20 if_acmpne 23 //弹出操作数栈的n1,n2的引用，并比较这两个引用值是否相等。 
22 return

0 iconst_1 // 将整型常量1压入操作数栈。 
1 istore_3 [n3] //弹出刚压入栈的整型常量1，将其存储在局部变量区的第3个位置上 
2 iconst_1 // 将整型常量1压入操作数栈。 
3 istore 4 [n4] //弹出刚压入栈的整型常量1，将其存储在局部变量区的第4个位置上 
5 iload_3 [n3] //将局部变量3中的整型常量1压入操作数栈 
6 iload 4 [n4] //将局部变量3中的整型常量2压入操作数栈 
8 if_icmpne 34 //弹出刚压入栈的两个整型常量，并比较这两个整型常量是否相等。 
11 return

Integer n1=new Integer(1); 
Integer n2=new Integer(1);
if(n1.equals(n2)); //true

public boolean equals(Object obj) {
     if (obj instanceof Integer) { 
           return value == ((Integer)obj).intValue(); 
     }
     return false; 
}

Value v1=new Value(1); //Value是自定义类，其中并没有定义equals()方法。
Value v2=new Value(1); 
if(v1.equals(v2)); //false

public boolean equals(Object obj) {
     return (this == obj); 
}

String s1=new String("aaaa"); 
String s2=new String("aaaa"); 
if(s1==s2); //false 
if(s1.equals(s2)); //true

String s3="aaaa"; 
String s4="aaaa"; 
if(s3==s4); // true 
if(s3.equals(s4)); //true

0  ldc <String "aaaa"> [13]  //将常量池中"aaa"字符串常量指向的堆中拘留String对象的地址压入操作数栈
2  astore_1  //弹出栈顶值，并将其存储在局部变量区的第1个位置上
3  ldc <String "aaaa"> [13]  //将常量池中"aaa"字符串常量指向的堆中拘留String对象的地址压入操作数栈
5  astore_2  //弹出栈顶值，并将其存储在局部变量区的第2个位置上
6  aload_1 //将局部变量1压入操作数栈
7  aload_2 //将局部变量2压入操作数栈
8  if_acmpne 11  //弹出两个栈顶值进行比较

Integer a=127;
Integer b=127; 
if(a==b); //结果：true

Integer c=128;
Integer d=128; 
if(c==d); //结果：false

/**
 * Returns a <tt>Integer</tt> instance representing the specified
 * <tt>int</tt> value.
 * If a new <tt>Integer</tt> 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.
 *
 * @param i an <code>int</code> value.
 * @return a <tt>Integer</tt> instance representing <tt>i</tt>.
 * @since 1.5
 */

public static Integer valueOf(int i) {
      final int offset = 128;
      if (i >= -128 && i <= 127) { // must cache
           return IntegerCache.cache[i + offset];
      }
      return new Integer(i);
}
private static class IntegerCache {
      private IntegerCache(){
      }
      static final Integer cache[]= new Integer[-(-128) + 127 + 1];
      static {
           for(int i = 0; i < cache.length; i++)
                cache[i] = new Integer(i - 128);
      }
}