Java面试DAY2

1、Java自动装箱与拆箱

装箱就是自动将基本数据类型转换为包装器类型（int-->Integer）；调用方法：Integer的 valueOf(int) 方法

拆箱就是自动将包装器类型转换为基本数据类型（Integer-->int）。调用方法：Integer的intValue方法

在Java SE5之前，如果要生成一个数值为10的Integer对象，必须这样进行：

Integer i = new Integer(10);

而在从Java SE5开始就提供了自动装箱的特性，如果要生成一个数值为10的Integer对象，只需要这样就可以了：

Integer i = 10;

面试题1： 以下代码会输出什么？

public class Main {
　　public static void main(String[] args) {
　　　　Integer i1 = 100;
　　　　Integer i2 = 100;
　　　　Integer i3 = 200;
　　　　Integer i4 = 200;
　　　　System.out.println(i1==i2);
　　　　System.out.println(i3==i4);
　　}
}

运行结果：

true
false

为什么会出现这样的结果？输出结果表明i1和i2指向的是同一个对象，而i3和i4指向的是不同的对象。此时只需一看源码便知究竟，下面这段代码是Integer的valueOf方法的具体实现：

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

其中IntegerCache类的实现为：

private static class IntegerCache {
　　static final int high;
　　static final Integer cache[];
　　static {
　　　　final int low = -128;
　　　　// high value may be configured by property
　　　　int h = 127;
　　　　if (integerCacheHighPropValue != null) {
　　　　　　// Use Long.decode here to avoid invoking methods that
　　　　　　// require Integer's autoboxing cache to be initialized
　　　　　　int i = Long.decode(integerCacheHighPropValue).intValue();
　　　　　　i = Math.max(i, 127);
　　　　　　// Maximum array size is Integer.MAX_VALUE
　　　　　　h = Math.min(i, Integer.MAX_VALUE - -low);
　　　　}
　　　　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() {}
　　}
}

这2段代码可以看出，在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。 上面的代码中i1和i2的数值为100，因此会直接从cache中取已经存在的对象，所以i1和i2指向的是同一个对象，而i3和i4则是分别指向不同的对象。

面试题2：以下代码输出什么？

public class Main {
　　public static void main(String[] args) {
　　　　Double i1 = 100.0;
　　　　Double i2 = 100.0;
　　　　Double i3 = 200.0;
　　　　Double i4 = 200.0;
　　　　System.out.println(i1==i2);
　　　　System.out.println(i3==i4);
　　}
}

运行结果：

false
false

原因： 在某个范围内的整型数值的个数是有限的，而浮点数却不是。

2、 重载和重写的区别

重写(Override)

从字面上看，重写就是重新写一遍的意思。其实就是在子类中把父类本身有的方法重新写一遍。子类继承了父类原有的方法，但有时子类并不想原封不动的继承父类中的某个方法，所以在方法名，参数列表，返回类型(子类中方法的返回值是父类中方法返回值的子类时)都相同的情况下，对方法体进行修改或重写，这就是重写。但要注意子类函数的访问修饰权限不能少于父类的。

public class Father {
　　public static void main(String[] args) {
　　　　// TODO Auto-generated method stub
　　　　Son s = new Son();
　　　　s.sayHello();
　　}
　　public void sayHello() {
　　　　System.out.println("Hello");
　　}
}
class Son extends Father{
　　@Override
　　public void sayHello() {
　　　　// TODO Auto-generated method stub
　　　　System.out.println("hello by ");
　　}
}

重写 总结：

1. 发生在父类与子类之间

2. 方法名，参数列表，返回类型（子类中方法的返回类型是父类中返回类型的子类）必须相同

3. 访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private)

4. 重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常

重载（Overload）

在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同）则视为重载。同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是否相同来判断重载。

public class Father {
　　public static void main(String[] args) {
　　　　// TODO Auto-generated method stub
　　　　Father s = new Father();
　　　　s.sayHello();
　　　　s.sayHello("wintershii");
　　}
　　public void sayHello() {
　　　　System.out.println("Hello");
　　}
　　public void sayHello(String name) {
　　　　System.out.println("Hello" + " " + name);
　　}
}

重载 总结：

1. 重载Overload是一个类中多态性的一种表现

2. 重载要求同名方法的参数列表不同(参数类型，参数个数甚至是参数顺序)

3. 重载的时候，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准

3、 equals与==的区别

==：

== 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。

1、比较的是操作符两端的操作数是否是同一个对象。

2、两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过。

3、比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为true，如： int a=10 与 long b=10L 与 double c=10.0都是相同的（为true），因为他们都指向地址为10的堆。

equals：

equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断。

总结： 所有比较是否相等时，都是用equals 并且在对常量相比较时，把常量写在前面，因为使用object的equals object可能为null，则空指针在阿里的代码规范中只使用equals ，阿里插件默认会识别，并可以快速修改，推荐安装阿里插件来排查老代码使用“==”，替换成equals

4、 Hashcode的作用

java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法就会比较慢。

于是有人发明了哈希算法来提高集合中查找元素的效率。 这种方式将集合分成若干个存储区域，每个对象可以计算出一个哈希码，可以将哈希码分组，每组分别对应某个存储区域，根据一个对象的哈希码就可以确定该对象应该存储的那个区域。

hashCode方法可以这样理解：它返回的就是根据对象的内存地址换算出的一个值。这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。

5、String、String StringBuffer 和 StringBuilder 的区别是什么?

String是只读字符串，它并不是基本数据类型，而是一个对象。从底层源码来看是一个final类型的字符 数组，所引用的字符串不能被改变，一经定义，无法再增删改。每次对String的操作都会生成新的String对象。

private final char value[];

每次+操作 ： 隐式在堆上new了一个跟原字符串相同的StringBuilder对象，再调用append方法 拼接+后面的字符。

StringBuffer和StringBuilder他们两都继承了AbstractStringBuilder抽象类，从AbstractStringBuilder 抽象类中我们可以看到

/**
* The value is used for character storage.
*/
char[] value;

他们的底层都是可变的字符数组，所以在进行频繁的字符串操作时，建议使用StringBuffer和 StringBuilder来进行操作。另外StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。