在招聘面试的时候，通常会有基础面试环节，在这个环节，我常常会给面试者出一些经典的基础题，大多都能在网上找到这些题目，题目不难，但却能很好的反映出面试者的基础扎实与否。当然，出这些题的目的并不是为了为难面试者，而是希望从另一个角度去了解面试者真正的编码水平以及对源代码的了解程度。
结合面试通过与否的结果来看，如果一个工作3～5年的开发工程师，对这些基础知识掌握不好，是会影响到最后的面试结果。当然，如果1～3年的开发工程师，如果对这些基础知识回答的很好，同样是很好的加分项。
下面来看看这几道经典的基础题吧！
一、判断Integer是否相等
Integer a = 127, b = 127;
Integer c = 128, d = 128;
Integer e = new Integer(128);
Integer m = new Integer(10);
Integer n = new Integer(10);
System.out.println(a == b);
System.out.println(c == d);
System.out.println(e == c);
System.out.println(m == n);
上面代码运行的结果如下：
true
false
false
false
你回答对了么？
出这道题的目的是因为Integer这个类比较特殊，很多人在使用的过程中，只是注意了Java的自动拆箱装箱，但是对Integer的缓存没有了解过，就会在使用的过程出现问题。比如比较两个集合的个数是否相等的时候，常常会出现问题。
/**
* 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 -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) {
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);
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
}
private IntegerCache() {}
}
/**
* 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);
}
以上代码摘自Integer中的源代码，从代码我们可以看出，在Integer这个类中，包含了一个IntegerCache的内部类，该类的主要功能就是缓存了[-128~127]的数据，而valueOf方法主要就是返回自动装箱的结果。
知道上面这些知识点后，我们再来分析一下上面的题目：
当我们声明Integer a = 127, b = 127;时，Java会进行自动装箱操作，简单点说，也就是把基本数据类型转换成Integer对象，而转换成Integer对象正是调用的valueOf方法，可以看到，IntegerCache把[-128~127]缓存了下来。所以，System.out.println(a == b);的输出结果是true，而System.out.println(c == d);的输出结果是false。
至于为什么会缓存[-128~127]，官方解释是小的数字使用的频率比较高，所以为了优化性能，把这之间的数缓存了下来。
至于后面两个的输出结果则很好解释，但凡使用new关键字的，就是需要在堆内存上开辟空间来进行数据的存储，而每new一个对象出来，在堆中的地址都是不同的，==在这里判断的是地址相等，所以后两个的输出结果是false。
总结：
1. Integer中的缓存范围是[-128~127]之间，超出这个范围都将新建Integer实例
2. 代码中装箱类（如Integer对象）的比较，尽量使用equals()方法去比较值相等与否，而尽量不要使用==判断相等。
3. 对于==，如果作用于 基本数据类型 的变量，则直接比较其存储的 “值”是否相等；如果作用于 引用类型 的变量，则比较的是所指向的对象的地址
二、判断String值是否相等
String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
System.out.println(s1 == s2);
System.out.println(s1 == s3);
以上代码的输出结果如下：
true
false
你答对了么？
对于第二个输出false大家应该都可以理解，第一个输出true就让人比较费解了，难道String也有IntegerCache的缓存么？
并不是，这是由于jvm虚拟机运行时数据区的“设计”所决定的，一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配，而堆内存中则存放new 出来的对象和数组。
然而除此之外还有一块区域叫做常量池。通常像String s1 = "abc"; 这样声明的字符串对象，其值就是存储在常量池中。当我们创建String s1 = "abc"这样一个对象之后，"abc"就存储到了常量池（也可叫做字符串池）中，当我们创建引用String s2 = "abc" 的时候，Java底层会优先在常量池中查找是否存在"abc"，如果存在则让s2指向这个值，不会重新创建，如果常量池中没有则创建并添加的池中。这就是为什么System.out.println(s1 == s2);答案是true的原因。
