Java ==: String Intern and Integer Cache

Integer int ==

public void testIntegerCache() {
  Integer i = 123;
  Integer j = 123;
  
  assertTrue(i == j);
  
  Integer heapK = new Integer(123);
  assertFalse(i == heapK);
  // heapK is auto-unboxed to the primitive value 123
  assertTrue(123 == heapK);
  
  // when value is beteween [-128, 127], java returns from its constant cache
  assertTrue(Integer.valueOf("123") == Integer.valueOf("123"));
  
  Integer cacheL = Integer.valueOf("123");
  assertTrue(i == cacheL);
}

Integer and Long cache numbers between -128 and 127.

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);
}

String ==

public void testStringIntern() {
  String a = "123";
  String b = "123";
  
  // There is only one 123, stored in java string constant pool.
  assertTrue(a == b);
  
  String heapC = new String("123");
  assertFalse(a == heapC);
  
  String internD = new String("123").intern();
  assertTrue(a == internD);
  
  // Special case
  assertTrue(String.valueOf(Integer.MIN_VALUE) == String
      .valueOf(Integer.MIN_VALUE));
  assertFalse(String.valueOf(Integer.MAX_VALUE) == String
      .valueOf(Integer.MAX_VALUE));
}

Boolean boolean ==

public void testBoolean() {
  boolean a = true;
  Boolean b = new Boolean(true);
  // auto-unbox, here Boolean b is auto-unboxed to the primitive boolean true.
  assertTrue(a == b);
  
  Boolean c = Boolean.valueOf("1");
  // different object
  assertFalse(b == c);
  
  // Boolean.valueOf actually returns one of two static final instance: TRUE,
  // FALSE
  Boolean d = Boolean.valueOf("1");
  assertTrue(c == d);
}